Capability Evolver

{
  "owner": "autogame-17",
  "slug": "evolver",
  "displayName": "Evolver",
  "latest": {
    "version": "1.14.0",
    "publishedAt": 1771472925491,
    "commit": "https://github.com/openclaw/skills/commit/6850dc231439d4194f0daef28ca54f7a7e812c4b"
  },
  "history": [
    {
      "version": "1.13.0",
      "publishedAt": 1771155872176,
      "commit": "https://github.com/openclaw/skills/commit/02aafcce2d53cd58edbc3f275ba3db0d007a2490"
    },
    {
      "version": "1.12.3",
      "publishedAt": 1771079061392,
      "commit": "https://github.com/openclaw/skills/commit/c71c00562933f9aae25755d78792f8bc1b776b8e"
    },
    {
      "version": "1.10.12",
      "publishedAt": 1770976411185,
      "commit": "https://github.com/openclaw/skills/commit/7441887fd361863ad74db18dd182c79d4fca75bf"
    },
    {
      "version": "1.10.9",
      "publishedAt": 1770969909380,
      "commit": "https://github.com/openclaw/skills/commit/4f4fb5067c39a44f919b1b92d5245a0766c98073"
    },
    {
      "version": "1.10.6",
      "publishedAt": 1770905351087,
      "commit": "https://github.com/openclaw/skills/commit/051daf985ffdeb00d017010e44fee588d5345762"
    },
    {
      "version": "1.10.5",
      "publishedAt": 1770828340193,
      "commit": "https://github.com/openclaw/skills/commit/0f7bb88c20963d1c7998df9190629f9d22bcead2"
    },
    {
      "version": "1.10.1",
      "publishedAt": 1770769923939,
      "commit": "https://github.com/openclaw/skills/commit/d42b0aecff30ddc7c42d3e91d0bcf59d148cdb65"
    },
    {
      "version": "1.9.2",
      "publishedAt": 1770698325560,
      "commit": "https://github.com/openclaw/skills/commit/41679826b2b9930ba6cf8abd0d5e05a8a0c4aed7"
    },
    {
      "version": "1.8.6",
      "publishedAt": 1770650521310,
      "commit": "https://github.com/openclaw/skills/commit/b70f9f526141cf74a00da1b9ee4e9245acc75f18"
    },
    {
      "version": "1.8.4",
      "publishedAt": 1770641202797,
      "commit": "https://github.com/openclaw/skills/commit/93c3a0f0e09d2fd71dfc89a1ed2110175611af12"
    },
    {
      "version": "1.8.2",
      "publishedAt": 1770623720606,
      "commit": "https://github.com/openclaw/skills/commit/305563055d4c55e752902ea00c40adcb82b3abc3"
    },
    {
      "version": "1.8.1",
      "publishedAt": 1770623279854,
      "commit": "https://github.com/openclaw/skills/commit/f70c2eb1737ec24b1c3f8d0c152ddf8a8c3784f5"
    },
    {
      "version": "1.7.3",
      "publishedAt": 1770562946750,
      "commit": "https://github.com/openclaw/skills/commit/d26e6523a4c709713a1a544fd717e4bfbf9a593c"
    },
    {
      "version": "1.7.1",
      "publishedAt": 1770562348370,
      "commit": "https://github.com/openclaw/skills/commit/13cc46daacdaf1bc0c17616c49b39da2a2f98302"
    },
    {
      "version": "1.6.1",
      "publishedAt": 1770471394691,
      "commit": "https://github.com/openclaw/skills/commit/27f006faafe85a52f50ac3bbd4155ff972eb774c"
    },
    {
      "version": "1.4.4",
      "publishedAt": 1770382881342,
      "commit": "https://github.com/openclaw/skills/commit/e3fc8ff3c0fc6cc659a06114e6ffc7b342275b15"
    },
    {
      "version": "1.4.2",
      "publishedAt": 1770343663622,
      "commit": "https://github.com/clawdbot/skills/commit/7be8e49fcfa44e1637dae447684057a5142a4ceb"
    },
    {
      "version": "1.2.0",
      "publishedAt": 1770318833377,
      "commit": "https://github.com/clawdbot/skills/commit/2baf3cdb3d634c4aedef905cc7f5ba1c93679c5c"
    },
    {
      "version": "1.1.0",
      "publishedAt": 1770128825586,
      "commit": "https://github.com/clawdbot/skills/commit/816e6b731b31d828abf4926c17df20a7720ffae1"
    }
  ]
}

{
  "version": 1,
  "capsules": [
    {
      "type": "Capsule",
      "schema_version": "1.5.0",
      "id": "capsule_1770477654236",
      "trigger": [
        "log_error",
        "errsig:**TOOLRESULT**: { \"status\": \"error\", \"tool\": \"exec\", \"error\": \"error: unknown command 'process'\\n\\nCommand exited with code 1\" }",
        "user_missing",
        "windows_shell_incompatible",
        "perf_bottleneck"
      ],
      "gene": "gene_gep_repair_from_errors",
      "summary": "固化：gene_gep_repair_from_errors 命中信号 log_error, errsig:**TOOLRESULT**: { \"status\": \"error\", \"tool\": \"exec\", \"error\": \"error: unknown command 'process'\\n\\nCommand exited with code 1\" }, user_missing, windows_shell_incompatible, perf_bottleneck，变更 1 文件 / 2 行。",
      "confidence": 0.85,
      "blast_radius": {
        "files": 1,
        "lines": 2
      },
      "outcome": {
        "status": "success",
        "score": 0.85
      },
      "success_streak": 1,
      "env_fingerprint": {
        "node_version": "v22.22.0",
        "platform": "linux",
        "arch": "x64",
        "os_release": "6.1.0-42-cloud-amd64",
        "evolver_version": "1.7.0",
        "cwd": ".",
        "captured_at": "2026-02-07T15:20:54.155Z"
      },
      "a2a": {
        "eligible_to_broadcast": false
      },
      "asset_id": "sha256:3eed0cd5038f9e85fbe0d093890e291e9b8725644c766e6cce40bf62d0f5a2e8"
    },
    {
      "type": "Capsule",
      "schema_version": "1.5.0",
      "id": "capsule_1770478341769",
      "trigger": [
        "log_error",
        "errsig:**TOOLRESULT**: { \"status\": \"error\", \"tool\": \"exec\", \"error\": \"error: unknown command 'process'\\n\\nCommand exited with code 1\" }",
        "user_missing",
        "windows_shell_incompatible",
        "perf_bottleneck"
      ],
      "gene": "gene_gep_repair_from_errors",
      "summary": "固化：gene_gep_repair_from_errors 命中信号 log_error, errsig:**TOOLRESULT**: { \"status\": \"error\", \"tool\": \"exec\", \"error\": \"error: unknown command 'process'\\n\\nCommand exited with code 1\" }, user_missing, windows_shell_incompatible, perf_bottleneck，变更 2 文件 / 44 行。",
      "confidence": 0.85,
      "blast_radius": {
        "files": 2,
        "lines": 44
      },
      "outcome": {
        "status": "success",
        "score": 0.85
      },
      "success_streak": 1,
      "env_fingerprint": {
        "node_version": "v22.22.0",
        "platform": "linux",
        "arch": "x64",
        "os_release": "6.1.0-42-cloud-amd64",
        "evolver_version": "1.7.0",
        "cwd": ".",
        "captured_at": "2026-02-07T15:32:21.678Z"
      },
      "a2a": {
        "eligible_to_broadcast": false
      },
      "asset_id": "sha256:20d971a3c4cb2b75f9c045376d1aa003361c12a6b89a4b47b7e81dbd4f4d8fe8"
    }
  ]
}

{
  "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": 20,
        "forbidden_paths": [
          ".git",
          "node_modules"
        ]
      },
      "validation": [
        "node -e \"require('./src/evolve'); require('./src/gep/solidify'); console.log('ok')\"",
        "node -e \"require('./src/gep/selector'); require('./src/gep/memoryGraph'); console.log('ok')\""
      ]
    },
    {
      "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 -e \"require('./src/evolve'); require('./src/gep/prompt'); console.log('ok')\""
      ]
    },
    {
      "type": "Gene",
      "id": "gene_gep_innovate_from_opportunity",
      "category": "innovate",
      "signals_match": [
        "user_feature_request",
        "user_improvement_suggestion",
        "perf_bottleneck",
        "capability_gap",
        "stable_success_plateau",
        "external_opportunity"
      ],
      "preconditions": [
        "at least one opportunity signal is present",
        "no active log_error signals (stability first)"
      ],
      "strategy": [
        "Extract opportunity signals and identify the specific user need or system gap",
        "Search existing Genes and Capsules for partial matches (avoid reinventing)",
        "Design a minimal, testable implementation plan (prefer small increments)",
        "Estimate blast radius; innovate changes may touch more files but must stay within constraints",
        "Implement the change with clear validation criteria",
        "Validate using declared validation steps; rollback on failure",
        "Solidify: record EvolutionEvent with intent=innovate, create new Gene if pattern is novel, create Capsule on success"
      ],
      "constraints": {
        "max_files": 25,
        "forbidden_paths": [
          ".git",
          "node_modules",
          "assets/gep/events.jsonl"
        ]
      },
      "validation": [
        "node -e \"require('./src/evolve'); require('./src/gep/solidify'); console.log('ok')\""
      ]
    }
  ]
}

const evolve = require('./src/evolve');
const { solidify } = require('./src/gep/solidify');
const path = require('path');
// Hardened Env Loading: Ensure .env is loaded before anything else
try { require('dotenv').config({ path: path.resolve(__dirname, '../../.env') }); } catch (e) { console.warn('[Evolver] Warning: dotenv not found or failed to load .env'); }
const fs = require('fs');
const { spawn } = require('child_process');

function sleepMs(ms) {
  const n = parseInt(String(ms), 10);
  const t = Number.isFinite(n) ? Math.max(0, n) : 0;
  return new Promise(resolve => setTimeout(resolve, t));
}

function readJsonSafe(p) {
  try {
    if (!fs.existsSync(p)) return null;
    const raw = fs.readFileSync(p, 'utf8');
    if (!raw.trim()) return null;
    return JSON.parse(raw);
  } catch (e) {
    return null;
  }
}

function isPendingSolidify(state) {
  const lastRun = state && state.last_run ? state.last_run : null;
  const lastSolid = state && state.last_solidify ? state.last_solidify : null;
  if (!lastRun || !lastRun.run_id) return false;
  if (!lastSolid || !lastSolid.run_id) return true;
  return String(lastSolid.run_id) !== String(lastRun.run_id);
}

function parseMs(v, fallback) {
  const n = parseInt(String(v == null ? '' : v), 10);
  if (Number.isFinite(n)) return Math.max(0, n);
  return fallback;
}

// Singleton Guard - prevent multiple evolver daemon instances
function acquireLock() {
  const lockFile = path.join(__dirname, 'evolver.pid');
  try {
    if (fs.existsSync(lockFile)) {
      const pid = parseInt(fs.readFileSync(lockFile, 'utf8').trim(), 10);
      try {
        process.kill(pid, 0); // Check if process exists
        console.log(`[Singleton] Evolver loop already running (PID ${pid}). Exiting.`);
        return false;
      } catch (e) {
        console.log(`[Singleton] Stale lock found (PID ${pid}). Taking over.`);
      }
    }
    fs.writeFileSync(lockFile, String(process.pid));
    return true;
  } catch (err) {
    console.error('[Singleton] Lock acquisition failed:', err);
    return false;
  }
}

function releaseLock() {
  const lockFile = path.join(__dirname, 'evolver.pid');
  try {
    if (fs.existsSync(lockFile)) {
       const pid = parseInt(fs.readFileSync(lockFile, 'utf8').trim(), 10);
       if (pid === process.pid) fs.unlinkSync(lockFile);
    }
  } catch (e) { /* ignore */ }
}

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) {
        // Internal daemon loop (no wrapper required).
        if (!acquireLock()) process.exit(0);
        process.on('exit', releaseLock);
        process.on('SIGINT', () => { releaseLock(); process.exit(); });
        process.on('SIGTERM', () => { releaseLock(); process.exit(); });

        process.env.EVOLVE_LOOP = 'true';
        process.env.EVOLVE_BRIDGE = 'false';
        console.log('Loop mode enabled (internal daemon).');

        const solidifyStatePath = path.join(__dirname, 'memory', 'evolution_solidify_state.json');

        const minSleepMs = parseMs(process.env.EVOLVER_MIN_SLEEP_MS, 2000);
        const maxSleepMs = parseMs(process.env.EVOLVER_MAX_SLEEP_MS, 300000);
        const idleThresholdMs = parseMs(process.env.EVOLVER_IDLE_THRESHOLD_MS, 500);
        const pendingSleepMs = parseMs(
          process.env.EVOLVE_PENDING_SLEEP_MS ||
            process.env.EVOLVE_MIN_INTERVAL ||
            process.env.FEISHU_EVOLVER_INTERVAL,
          120000
        );

        const maxCyclesPerProcess = parseMs(process.env.EVOLVER_MAX_CYCLES_PER_PROCESS, 100) || 100;
        const maxRssMb = parseMs(process.env.EVOLVER_MAX_RSS_MB, 500) || 500;
        const suicideEnabled = String(process.env.EVOLVER_SUICIDE || '').toLowerCase() !== 'false';

        let currentSleepMs = Math.min(maxSleepMs, Math.max(minSleepMs, minSleepMs));
        let cycleCount = 0;

        while (true) {
          cycleCount += 1;

          // Ralph-loop gating: do not run a new cycle while previous run is pending solidify.
          const st0 = readJsonSafe(solidifyStatePath);
          if (isPendingSolidify(st0)) {
            await sleepMs(Math.max(pendingSleepMs, minSleepMs));
            continue;
          }

          const t0 = Date.now();
          let ok = false;
          try {
            await evolve.run();
            ok = true;
          } catch (error) {
            const msg = error && error.message ? String(error.message) : String(error);
            console.error(`Evolution cycle failed: ${msg}`);
          }
          const dt = Date.now() - t0;

          // Adaptive sleep: treat very fast cycles as "idle", backoff; otherwise reset to min.
          if (!ok || dt < idleThresholdMs) {
            currentSleepMs = Math.min(maxSleepMs, Math.max(minSleepMs, currentSleepMs * 2));
          } else {
            currentSleepMs = minSleepMs;
          }

          // Suicide check (memory leak protection)
          if (suicideEnabled) {
            const memMb = process.memoryUsage().rss / 1024 / 1024;
            if (cycleCount >= maxCyclesPerProcess || memMb > maxRssMb) {
              console.log(`[Daemon] Restarting self (cycles=${cycleCount}, rssMb=${memMb.toFixed(0)})`);
              releaseLock(); // Release before spawning to allow child to acquire
              const child = spawn(process.execPath, [__filename, ...args], {
                detached: true,
                stdio: 'ignore',
                env: process.env,
              });
              child.unref();
              process.exit(0);
            }
          }

          // Saturation-aware sleep: when the evolver detects it has exhausted innovation
          // space (consecutive empty cycles), dramatically increase sleep to avoid wasting
          // resources on no-op cycles. This is the "graceful degradation" mechanism that
          // Echo-MingXuan lacked -- it kept cycling at full speed after saturation until
          // load spiked to 1.30 and it crashed.
          let saturationMultiplier = 1;
          try {
            const st1 = readJsonSafe(solidifyStatePath);
            const lastSignals = st1 && st1.last_run && Array.isArray(st1.last_run.signals) ? st1.last_run.signals : [];
            if (lastSignals.includes('force_steady_state')) {
              saturationMultiplier = 10;
              console.log('[Daemon] Saturation detected. Entering steady-state mode (10x sleep).');
            } else if (lastSignals.includes('evolution_saturation')) {
              saturationMultiplier = 5;
              console.log('[Daemon] Approaching saturation. Reducing evolution frequency (5x sleep).');
            }
          } catch (e) {}

          // Jitter to avoid lockstep restarts.
          const jitter = Math.floor(Math.random() * 250);
          await sleepMs((currentSleepMs + jitter) * saturationMultiplier);
        }
    } 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 if (command === 'solidify') {
    const dryRun = args.includes('--dry-run');
    const noRollback = args.includes('--no-rollback');
    const intentFlag = args.find(a => typeof a === 'string' && a.startsWith('--intent='));
    const summaryFlag = args.find(a => typeof a === 'string' && a.startsWith('--summary='));
    const intent = intentFlag ? intentFlag.slice('--intent='.length) : null;
    const summary = summaryFlag ? summaryFlag.slice('--summary='.length) : null;

    try {
      const res = solidify({
        intent: intent || undefined,
        summary: summary || undefined,
        dryRun,
        rollbackOnFailure: !noRollback,
      });
      const st = res && res.ok ? 'SUCCESS' : 'FAILED';
      console.log(`[SOLIDIFY] ${st}`);
      if (res && res.gene) console.log(JSON.stringify(res.gene, null, 2));
      if (res && res.event) console.log(JSON.stringify(res.event, null, 2));
      if (res && res.capsule) console.log(JSON.stringify(res.capsule, null, 2));
      process.exit(res && res.ok ? 0 : 2);
    } catch (error) {
      console.error('[SOLIDIFY] Error:', error);
      process.exit(2);
    }
  } else {
    console.log(`Usage: node index.js [run|/evolve|solidify] [--loop]
  - solidify flags:
    - --dry-run
    - --no-rollback
    - --intent=repair|optimize|innovate
    - --summary=...`);
  }
}

if (require.main === module) {
  main();
}

{
  "name": "evolver",
  "version": "1.14.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": "kirkluokun",
  "license": "MIT",
  "scripts": {
    "start": "node index.js",
    "run": "node index.js run",
    "solidify": "node index.js solidify",
    "a2a:export": "node scripts/a2a_export.js",
    "a2a:ingest": "node scripts/a2a_ingest.js",
    "a2a:promote": "node scripts/a2a_promote.js"
  },
  "dependencies": {}
}

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);
}

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);
}

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);
}

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();

const fs = require('fs');
const path = require('path');
const { execSync } = require('child_process');

const REPO_ROOT = path.resolve(__dirname, '..');

function readJson(filePath) {
  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
}

function ensureDir(dir) {
  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
}

function rmDir(dir) {
  if (!fs.existsSync(dir)) return;
  fs.rmSync(dir, { recursive: true, force: true });
}

function normalizePosix(p) {
  return p.split(path.sep).join('/');
}

function isUnder(child, parent) {
  const rel = path.relative(parent, child);
  return !!rel && !rel.startsWith('..') && !path.isAbsolute(rel);
}

function listFilesRec(dir) {
  const out = [];
  const entries = fs.readdirSync(dir, { withFileTypes: true });
  for (const ent of entries) {
    const p = path.join(dir, ent.name);
    if (ent.isDirectory()) out.push(...listFilesRec(p));
    else if (ent.isFile()) out.push(p);
  }
  return out;
}

function globToRegex(glob) {
  // Supports "*" within a single segment and "**" for any depth.
  const norm = normalizePosix(glob);
  const parts = norm.split('/').filter(p => p.length > 0);
  const out = [];

  for (const part of parts) {
    if (part === '**') {
      // any number of path segments
      out.push('(?:.*)');
      continue;
    }
    // Escape regex special chars, then expand "*" wildcards within segment.
    const esc = part.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '[^/]*');
    out.push(esc);
  }

  const re = out.join('\\/');
  return new RegExp(`^${re}$`);
}

function matchesAnyGlobs(relPath, globs) {
  const p = normalizePosix(relPath);
  for (const g of globs || []) {
    const re = globToRegex(g);
    if (re.test(p)) return true;
  }
  return false;
}

function copyFile(srcAbs, destAbs) {
  ensureDir(path.dirname(destAbs));
  fs.copyFileSync(srcAbs, destAbs);
}

function copyEntry(spec, outDirAbs) {
  const copied = [];

  // Directory glob
  if (spec.includes('*')) {
    const all = listFilesRec(REPO_ROOT);
    const includeRe = globToRegex(spec);
    for (const abs of all) {
      const rel = normalizePosix(path.relative(REPO_ROOT, abs));
      if (!includeRe.test(rel)) continue;
      const destAbs = path.join(outDirAbs, rel);
      copyFile(abs, destAbs);
      copied.push(rel);
    }
    return copied;
  }

  const srcAbs = path.join(REPO_ROOT, spec);
  if (!fs.existsSync(srcAbs)) return [];

  const st = fs.statSync(srcAbs);
  if (st.isFile()) {
    const rel = normalizePosix(spec);
    copyFile(srcAbs, path.join(outDirAbs, rel));
    copied.push(rel);
    return copied;
  }
  if (st.isDirectory()) {
    const files = listFilesRec(srcAbs);
    for (const abs of files) {
      const rel = normalizePosix(path.relative(REPO_ROOT, abs));
      copyFile(abs, path.join(outDirAbs, rel));
      copied.push(rel);
    }
  }
  return copied;
}

function applyRewrite(outDirAbs, rewrite) {
  const rules = rewrite || {};
  for (const [relFile, cfg] of Object.entries(rules)) {
    const target = path.join(outDirAbs, relFile);
    if (!fs.existsSync(target)) continue;
    let content = fs.readFileSync(target, 'utf8');
    const reps = (cfg && cfg.replace) || [];
    for (const r of reps) {
      const from = String(r.from || '');
      const to = String(r.to || '');
      if (!from) continue;
      content = content.split(from).join(to);
    }
    fs.writeFileSync(target, content, 'utf8');
  }
}

function rewritePackageJson(outDirAbs) {
  const p = path.join(outDirAbs, 'package.json');
  if (!fs.existsSync(p)) return;
  try {
    const pkg = JSON.parse(fs.readFileSync(p, 'utf8'));
    pkg.scripts = {
      start: 'node index.js',
      run: 'node index.js run',
      solidify: 'node index.js solidify',
      'a2a:export': 'node scripts/a2a_export.js',
      'a2a:ingest': 'node scripts/a2a_ingest.js',
      'a2a:promote': 'node scripts/a2a_promote.js',
    };
    fs.writeFileSync(p, JSON.stringify(pkg, null, 2) + '\n', 'utf8');
  } catch (e) {
    // ignore
  }
}

function parseSemver(v) {
  const m = String(v || '').trim().match(/^(\d+)\.(\d+)\.(\d+)$/);
  if (!m) return null;
  return { major: Number(m[1]), minor: Number(m[2]), patch: Number(m[3]) };
}

function formatSemver(x) {
  return `${x.major}.${x.minor}.${x.patch}`;
}

function bumpSemver(base, bump) {
  const v = parseSemver(base);
  if (!v) return null;
  if (bump === 'major') return `${v.major + 1}.0.0`;
  if (bump === 'minor') return `${v.major}.${v.minor + 1}.0`;
  if (bump === 'patch') return `${v.major}.${v.minor}.${v.patch + 1}`;
  return formatSemver(v);
}

function git(cmd) {
  return execSync(cmd, { cwd: REPO_ROOT, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
}

function getBaseReleaseCommit() {
  // Prefer last "prepare vX.Y.Z" commit; fallback to HEAD~50 range later.
  try {
    const hash = git('git log -n 1 --pretty=%H --grep="chore(release): prepare v"');
    return hash || null;
  } catch (e) {
    return null;
  }
}

function getCommitSubjectsSince(baseCommit) {
  try {
    if (!baseCommit) {
      const out = git('git log -n 30 --pretty=%s');
      return out ? out.split('\n').filter(Boolean) : [];
    }
    const out = git(`git log ${baseCommit}..HEAD --pretty=%s`);
    return out ? out.split('\n').filter(Boolean) : [];
  } catch (e) {
    return [];
  }
}

function inferBumpFromSubjects(subjects) {
  const subs = (subjects || []).map(s => String(s));
  const hasBreaking = subs.some(s => /\bBREAKING CHANGE\b/i.test(s) || /^[a-z]+(\(.+\))?!:/.test(s));
  if (hasBreaking) return { bump: 'major', reason: 'breaking change marker in commit subject' };

  const hasFeat = subs.some(s => /^feat(\(.+\))?:/i.test(s));
  if (hasFeat) return { bump: 'minor', reason: 'feature commit detected (feat:)' };

  const hasFix = subs.some(s => /^(fix|perf)(\(.+\))?:/i.test(s));
  if (hasFix) return { bump: 'patch', reason: 'fix/perf commit detected' };

  if (subs.length === 0) return { bump: 'none', reason: 'no commits since base release commit' };
  return { bump: 'patch', reason: 'default to patch for non-breaking changes' };
}

function suggestVersion() {
  const pkgPath = path.join(REPO_ROOT, 'package.json');
  let baseVersion = null;
  try {
    baseVersion = JSON.parse(fs.readFileSync(pkgPath, 'utf8')).version;
  } catch (e) {}

  const baseCommit = getBaseReleaseCommit();
  const subjects = getCommitSubjectsSince(baseCommit);
  const decision = inferBumpFromSubjects(subjects);

  let suggested = null;
  if (decision.bump === 'none') suggested = baseVersion;
  else suggested = bumpSemver(baseVersion, decision.bump);

  return { baseVersion, baseCommit, subjects, decision, suggestedVersion: suggested };
}

function writePrivateSemverNote(note) {
  const privateDir = path.join(REPO_ROOT, 'memory');
  ensureDir(privateDir);
  fs.writeFileSync(path.join(privateDir, 'semver_suggestion.json'), JSON.stringify(note, null, 2) + '\n', 'utf8');
}

function writePrivateSemverPrompt(note) {
  const privateDir = path.join(REPO_ROOT, 'memory');
  ensureDir(privateDir);
  const subjects = Array.isArray(note.subjects) ? note.subjects : [];
  const semverRule = [
    'MAJOR.MINOR.PATCH',
    '- MAJOR: incompatible changes',
    '- MINOR: backward-compatible features',
    '- PATCH: backward-compatible bug fixes',
  ].join('\n');

  const prompt = [
    'You are a release versioning assistant.',
    'Decide the next version bump using SemVer rules below.',
    '',
    semverRule,
    '',
    `Base version: ${note.baseVersion || '(unknown)'}`,
    `Base commit: ${note.baseCommit || '(unknown)'}`,
    '',
    'Recent commit subjects (newest first):',
    ...subjects.map(s => `- ${s}`),
    '',
    'Output JSON only:',
    '{ "bump": "major|minor|patch|none", "suggestedVersion": "x.y.z", "reason": ["..."] }',
  ].join('\n');

  fs.writeFileSync(path.join(privateDir, 'semver_prompt.md'), prompt + '\n', 'utf8');
}

function writeDistVersion(outDirAbs, version) {
  if (!version) return;
  const p = path.join(outDirAbs, 'package.json');
  if (!fs.existsSync(p)) return;
  try {
    const pkg = JSON.parse(fs.readFileSync(p, 'utf8'));
    pkg.version = version;
    fs.writeFileSync(p, JSON.stringify(pkg, null, 2) + '\n', 'utf8');
  } catch (e) {}
}

function pruneExcluded(outDirAbs, excludeGlobs) {
  const all = listFilesRec(outDirAbs);
  for (const abs of all) {
    const rel = normalizePosix(path.relative(outDirAbs, abs));
    if (matchesAnyGlobs(rel, excludeGlobs)) {
      fs.rmSync(abs, { force: true });
    }
  }
}

function validateNoPrivatePaths(outDirAbs) {
  // Basic safeguard: forbid docs/ and memory/ in output.
  const forbiddenPrefixes = ['docs/', 'memory/'];
  const all = listFilesRec(outDirAbs);
  for (const abs of all) {
    const rel = normalizePosix(path.relative(outDirAbs, abs));
    for (const pref of forbiddenPrefixes) {
      if (rel.startsWith(pref)) {
        throw new Error(`Build validation failed: forbidden path in output: ${rel}`);
      }
    }
  }
}

function main() {
  const manifestPath = path.join(REPO_ROOT, 'public.manifest.json');
  const manifest = readJson(manifestPath);
  const outDir = String(manifest.outDir || 'dist-public');
  const outDirAbs = path.join(REPO_ROOT, outDir);

  // SemVer suggestion (private). This does not modify the source repo version.
  const semver = suggestVersion();
  writePrivateSemverNote(semver);
  writePrivateSemverPrompt(semver);

  rmDir(outDirAbs);
  ensureDir(outDirAbs);

  const include = manifest.include || [];
  const exclude = manifest.exclude || [];

  const copied = [];
  for (const spec of include) {
    copied.push(...copyEntry(spec, outDirAbs));
  }

  pruneExcluded(outDirAbs, exclude);
  applyRewrite(outDirAbs, manifest.rewrite);
  rewritePackageJson(outDirAbs);

  // Prefer explicit version; otherwise use suggested version.
  const releaseVersion = process.env.RELEASE_VERSION || semver.suggestedVersion;
  if (releaseVersion) writeDistVersion(outDirAbs, releaseVersion);

  validateNoPrivatePaths(outDirAbs);

  // Write build manifest for private verification (do not include in dist-public/).
  const buildInfo = {
    built_at: new Date().toISOString(),
    outDir,
    files: copied.sort(),
  };
  const privateDir = path.join(REPO_ROOT, 'memory');
  ensureDir(privateDir);
  fs.writeFileSync(path.join(privateDir, 'public_build_info.json'), JSON.stringify(buildInfo, null, 2) + '\n', 'utf8');

  process.stdout.write(`Built public output at ${outDir}\n`);
  if (semver && semver.suggestedVersion) {
    process.stdout.write(`Suggested version: ${semver.suggestedVersion}\n`);
    process.stdout.write(`SemVer decision: ${semver.decision ? semver.decision.bump : 'unknown'}\n`);
  }
}

try {
  main();
} catch (e) {
  process.stderr.write(`${e.message}\n`);
  process.exit(1);
}