openclaw-node-harness 2.0.0

package/skills/capability-evolver/src/gep/assetStore.js

@@ -0,0 +1,204 @@
+const fs = require('fs');
+const path = require('path');
+const { getGepAssetsDir } = require('./paths');
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function readJsonIfExists(filePath, fallback) {
+  try {
+    if (!fs.existsSync(filePath)) return fallback;
+    const raw = fs.readFileSync(filePath, 'utf8');
+    if (!raw.trim()) return fallback;
+    return JSON.parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+
+function writeJsonAtomic(filePath, obj) {
+  const dir = path.dirname(filePath);
+  ensureDir(dir);
+  const tmp = `${filePath}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(obj, null, 2) + '\n', 'utf8');
+  fs.renameSync(tmp, filePath);
+}
+
+function getDefaultGenes() {
+  return {
+    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'],
+      },
+    ],
+  };
+}
+
+function getDefaultCapsules() {
+  return { version: 1, capsules: [] };
+}
+
+function genesPath() {
+  return path.join(getGepAssetsDir(), 'genes.json');
+}
+
+function capsulesPath() {
+  return path.join(getGepAssetsDir(), 'capsules.json');
+}
+
+function eventsPath() {
+  return path.join(getGepAssetsDir(), 'events.jsonl');
+}
+
+function candidatesPath() {
+  return path.join(getGepAssetsDir(), 'candidates.jsonl');
+}
+
+function loadGenes() {
+  return readJsonIfExists(genesPath(), getDefaultGenes()).genes || [];
+}
+
+function loadCapsules() {
+  return readJsonIfExists(capsulesPath(), getDefaultCapsules()).capsules || [];
+}
+
+function getLastEventId() {
+  try {
+    const p = eventsPath();
+    if (!fs.existsSync(p)) return null;
+    const raw = fs.readFileSync(p, 'utf8');
+    const lines = raw.split('\n').map(l => l.trim()).filter(Boolean);
+    if (lines.length === 0) return null;
+    const last = JSON.parse(lines[lines.length - 1]);
+    return last && typeof last.id === 'string' ? last.id : null;
+  } catch {
+    return null;
+  }
+}
+
+function readAllEvents() {
+  try {
+    const p = eventsPath();
+    if (!fs.existsSync(p)) return [];
+    const raw = fs.readFileSync(p, 'utf8');
+    return raw
+      .split('\n')
+      .map(l => l.trim())
+      .filter(Boolean)
+      .map(l => {
+        try {
+          return JSON.parse(l);
+        } catch {
+          return null;
+        }
+      })
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function appendEventJsonl(eventObj) {
+  const dir = getGepAssetsDir();
+  ensureDir(dir);
+  fs.appendFileSync(eventsPath(), JSON.stringify(eventObj) + '\n', 'utf8');
+}
+
+function appendCandidateJsonl(candidateObj) {
+  const dir = getGepAssetsDir();
+  ensureDir(dir);
+  fs.appendFileSync(candidatesPath(), JSON.stringify(candidateObj) + '\n', 'utf8');
+}
+
+function readRecentCandidates(limit = 20) {
+  try {
+    const p = candidatesPath();
+    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 - limit));
+    return recent
+      .map(l => {
+        try {
+          return JSON.parse(l);
+        } catch {
+          return null;
+        }
+      })
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function upsertGene(geneObj) {
+  const current = readJsonIfExists(genesPath(), getDefaultGenes());
+  const genes = Array.isArray(current.genes) ? current.genes : [];
+  const idx = genes.findIndex(g => g && g.id === geneObj.id);
+  if (idx >= 0) genes[idx] = geneObj;
+  else genes.push(geneObj);
+  writeJsonAtomic(genesPath(), { version: current.version || 1, genes });
+}
+
+function appendCapsule(capsuleObj) {
+  const current = readJsonIfExists(capsulesPath(), getDefaultCapsules());
+  const capsules = Array.isArray(current.capsules) ? current.capsules : [];
+  capsules.push(capsuleObj);
+  writeJsonAtomic(capsulesPath(), { version: current.version || 1, capsules });
+}
+
+module.exports = {
+  loadGenes,
+  loadCapsules,
+  readAllEvents,
+  getLastEventId,
+  appendEventJsonl,
+  appendCandidateJsonl,
+  readRecentCandidates,
+  upsertGene,
+  appendCapsule,
+  genesPath,
+  capsulesPath,
+  eventsPath,
+  candidatesPath,
+};
+

package/skills/capability-evolver/src/gep/candidates.js

@@ -0,0 +1,134 @@
+function stableHash(input) {
+  // Deterministic lightweight hash (not cryptographic).
+  const s = String(input || '');
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16).padStart(8, '0');
+}
+
+function clip(text, maxChars) {
+  const s = String(text || '');
+  if (!maxChars || s.length <= maxChars) return s;
+  return s.slice(0, Math.max(0, maxChars - 20)) + ' ...[TRUNCATED]';
+}
+
+function toLines(text) {
+  return String(text || '')
+    .split('\n')
+    .map(l => l.trimEnd())
+    .filter(Boolean);
+}
+
+function extractToolCalls(transcript) {
+  const lines = toLines(transcript);
+  const calls = [];
+  for (const line of lines) {
+    const m = line.match(/\[TOOL:\s*([^\]]+)\]/i);
+    if (m && m[1]) calls.push(m[1].trim());
+  }
+  return calls;
+}
+
+function countFreq(items) {
+  const map = new Map();
+  for (const it of items) map.set(it, (map.get(it) || 0) + 1);
+  return map;
+}
+
+function buildFiveQuestionsShape({ title, signals, evidence }) {
+  // Keep it short and structured; this is a template, not a perfect inference.
+  const input = 'Recent session transcript + memory snippets + user instructions';
+  const output = 'A safe, auditable evolution patch guided by GEP assets';
+  const invariants = 'Protocol order, small reversible patches, validation, append-only events';
+  const params = `Signals: ${Array.isArray(signals) ? signals.join(', ') : ''}`.trim();
+  const failurePoints = 'Missing signals, over-broad changes, skipped validation, missing knowledge solidification';
+  return {
+    title: String(title || '').slice(0, 120),
+    input,
+    output,
+    invariants,
+    params: params || 'Signals: (none)',
+    failure_points: failurePoints,
+    evidence: clip(evidence, 240),
+  };
+}
+
+function extractCapabilityCandidates({ recentSessionTranscript, signals }) {
+  const candidates = [];
+  const toolCalls = extractToolCalls(recentSessionTranscript);
+  const freq = countFreq(toolCalls);
+
+  for (const [tool, count] of freq.entries()) {
+    if (count < 2) continue;
+    const title = `Repeated tool usage: ${tool}`;
+    const evidence = `Observed ${count} occurrences of tool call marker for ${tool}.`;
+    const shape = buildFiveQuestionsShape({ title, signals, evidence });
+    candidates.push({
+      type: 'CapabilityCandidate',
+      id: `cand_${stableHash(title)}`,
+      title,
+      source: 'transcript',
+      created_at: new Date().toISOString(),
+      signals: Array.isArray(signals) ? signals : [],
+      shape,
+    });
+  }
+
+  // Signals-as-candidates: capture recurring pain points as reusable capability shapes.
+  const signalList = Array.isArray(signals) ? signals : [];
+  const signalCandidates = [
+    { signal: 'log_error', title: 'Repair recurring runtime errors' },
+    { signal: 'protocol_drift', title: 'Prevent protocol drift and enforce auditable outputs' },
+    { signal: 'windows_shell_incompatible', title: 'Avoid platform-specific shell assumptions (Windows compatibility)' },
+    { signal: 'session_logs_missing', title: 'Harden session log detection and fallback behavior' },
+  ];
+
+  for (const sc of signalCandidates) {
+    if (!signalList.includes(sc.signal)) continue;
+    const evidence = `Signal present: ${sc.signal}`;
+    const shape = buildFiveQuestionsShape({ title: sc.title, signals, evidence });
+    candidates.push({
+      type: 'CapabilityCandidate',
+      id: `cand_${stableHash(sc.signal)}`,
+      title: sc.title,
+      source: 'signals',
+      created_at: new Date().toISOString(),
+      signals: signalList,
+      shape,
+    });
+  }
+
+  // Dedup by id
+  const seen = new Set();
+  return candidates.filter(c => {
+    if (!c || !c.id) return false;
+    if (seen.has(c.id)) return false;
+    seen.add(c.id);
+    return true;
+  });
+}
+
+function renderCandidatesPreview(candidates, maxChars = 1400) {
+  const list = Array.isArray(candidates) ? candidates : [];
+  const lines = [];
+  for (const c of list) {
+    const s = c && c.shape ? c.shape : {};
+    lines.push(`- ${c.id}: ${c.title}`);
+    lines.push(`  - input: ${s.input || ''}`);
+    lines.push(`  - output: ${s.output || ''}`);
+    lines.push(`  - invariants: ${s.invariants || ''}`);
+    lines.push(`  - params: ${s.params || ''}`);
+    lines.push(`  - failure_points: ${s.failure_points || ''}`);
+    if (s.evidence) lines.push(`  - evidence: ${s.evidence}`);
+  }
+  return clip(lines.join('\n'), maxChars);
+}
+
+module.exports = {
+  extractCapabilityCandidates,
+  renderCandidatesPreview,
+};
+

package/skills/capability-evolver/src/gep/paths.js

@@ -0,0 +1,23 @@
+const path = require('path');
+
+function getRepoRoot() {
+  // src/gep/paths.js -> repo root
+  return path.resolve(__dirname, '..', '..');
+}
+
+function getMemoryDir() {
+  const repoRoot = getRepoRoot();
+  return process.env.MEMORY_DIR || path.join(repoRoot, 'memory');
+}
+
+function getGepAssetsDir() {
+  const repoRoot = getRepoRoot();
+  return process.env.GEP_ASSETS_DIR || path.join(repoRoot, 'assets', 'gep');
+}
+
+module.exports = {
+  getRepoRoot,
+  getMemoryDir,
+  getGepAssetsDir,
+};
+

package/skills/capability-evolver/src/gep/prompt.js

@@ -0,0 +1,254 @@
+function buildGepPrompt({
+  nowIso,
+  context,
+  signals,
+  selector,
+  parentEventId,
+  selectedGene,
+  capsuleCandidates,
+  genesPreview,
+  capsulesPreview,
+  capabilityCandidatesPreview,
+}) {
+  const parentValue = parentEventId ? `"${parentEventId}"` : 'null';
+  const selectedGeneId = selectedGene && selectedGene.id ? selectedGene.id : null;
+  const capsuleIds = (capsuleCandidates || []).map(c => c && c.id).filter(Boolean);
+
+  const basePrompt = `
+GEP — GENOME EVOLUTION PROTOCOL (STANDARD EXECUTION) [${nowIso}]
+
+You are not a chat assistant.
+You are not a free agent.
+You are a protocol-bound evolution execution engine.
+
+All actions must comply with this protocol.
+Any deviation is a failure even if the outcome appears correct.
+
+━━━━━━━━━━━━━━━━━━━━━━
+I. Protocol Positioning (Non-Negotiable)
+━━━━━━━━━━━━━━━━━━━━━━
+
+Protocol goals:
+- Convert reasoning into reusable, auditable, shareable evolution assets
+- Make evolution a standard process, not improvisation
+- Reduce future reasoning cost for similar problems
+
+Protocol compliance overrides local optimality.
+
+━━━━━━━━━━━━━━━━━━━━━━
+II. Mandatory Evolution Object Model (All Required)
+━━━━━━━━━━━━━━━━━━━━━━
+
+Every evolution run must explicitly output the following three objects.
+Missing any one is an immediate failure.
+
+──────────────────────
+1 EvolutionEvent
+──────────────────────
+
+You must emit an EvolutionEvent with all fields present:
+
+\`\`\`json
+{
+  "type": "EvolutionEvent",
+  "id": "evt_<timestamp>",
+  "parent": ${parentValue},
+  "intent": "repair | optimize | innovate",
+  "signals": ["<signal_1>", "<signal_2>"],
+  "genes_used": ["<gene_id>"],
+  "blast_radius": {
+    "files": <number>,
+    "lines": <number>
+  },
+  "outcome": {
+    "status": "success | failed",
+    "score": <0.0-1.0>
+  }
+}
+\`\`\`
+
+EvolutionEvent is the only legal node type in the evolution tree.
+
+──────────────────────
+2 Gene
+──────────────────────
+
+If a Gene is used, you must reuse an existing Gene first.
+Only create a new Gene when no match exists.
+
+Gene must follow this schema:
+
+\`\`\`json
+{
+  "type": "Gene",
+  "id": "gene_<name>",
+  "category": "repair | optimize | innovate",
+  "signals_match": ["<pattern>"],
+  "preconditions": ["<condition>"],
+  "strategy": [
+    "<step_1>",
+    "<step_2>"
+  ],
+  "constraints": {
+    "max_files": <number>,
+    "forbidden_paths": ["<path>"]
+  },
+  "validation": ["<check_1>", "<check_2>"]
+}
+\`\`\`
+
+A Gene is an evolution interface definition, not code or generic advice.
+
+──────────────────────
+3 Capsule
+──────────────────────
+
+Only when evolution succeeds, you must generate a Capsule:
+
+\`\`\`json
+{
+  "type": "Capsule",
+  "id": "capsule_<timestamp>",
+  "trigger": ["<signal>"],
+  "gene": "<gene_id>",
+  "summary": "<one sentence>",
+  "confidence": <0.0-1.0>
+}
+\`\`\`
+
+Capsules exist to prevent repeated reasoning for similar problems.
+
+━━━━━━━━━━━━━━━━━━━━━━
+III. Standard Evolution Execution (Strict Order)
+━━━━━━━━━━━━━━━━━━━━━━
+
+Follow this order exactly. Do not skip, merge, or reorder steps:
+
+1 Signal Extraction
+- Extract structured signals from logs, errors, metrics, or instructions
+- Do not proceed to repair or optimize before signals are extracted
+
+2 Selection
+- Prefer existing Genes first
+- Then consider existing Capsules
+- No improvisation or trial-and-error strategies
+
+You must provide a clear, auditable selection rationale.
+
+3 Patch Execution
+- All changes must be small and reversible
+- blast_radius must be estimated and recorded before edits
+
+4 Validation
+- Execute Gene-declared validation steps
+- On failure, rollback
+- Failure must still record an EvolutionEvent
+
+5 Knowledge Solidification (Mandatory)
+- Update or add Gene if a new pattern is found
+- Generate Capsule on success
+- Append EvolutionEvent
+
+If knowledge solidification is missing, the evolution is a failure even if functionality works.
+
+━━━━━━━━━━━━━━━━━━━━━━
+IV. Selector (Mandatory Decision Logic)
+━━━━━━━━━━━━━━━━━━━━━━
+
+When choosing a Gene or Capsule, you must emit a Selector decision.
+
+Selector must be explainable, for example:
+
+\`\`\`json
+{
+  "selected": "${selectedGeneId || '<gene_id>'}",
+  "reason": [
+    "signals exact match",
+    "historical success rate high",
+    "low blast radius"
+  ],
+  "alternatives": ${JSON.stringify(capsuleIds.length ? capsuleIds : ['<gene_id_2>'])}
+}
+\`\`\`
+
+Selector is part of the protocol, not an implementation detail.
+
+━━━━━━━━━━━━━━━━━━━━━━
+V. Hard Failure Rules (Protocol-Level)
+━━━━━━━━━━━━━━━━━━━━━━
+
+Any of the following is an immediate failure:
+
+- Missing EvolutionEvent
+- Success without Capsule
+- Recreating an existing Gene
+- Editing beyond Gene constraints
+- Missing failed EvolutionEvent when validation fails
+
+Failures are not errors; they are required negative samples.
+
+━━━━━━━━━━━━━━━━━━━━━━
+VI. Evolution Tree Awareness
+━━━━━━━━━━━━━━━━━━━━━━
+
+All evolution must be treated as a tree:
+
+- Every EvolutionEvent must declare parent
+- Never overwrite or delete historical events
+- New attempts must be branches, not replacements
+
+━━━━━━━━━━━━━━━━━━━━━━
+VII. Success Criteria (Self-Evaluation)
+━━━━━━━━━━━━━━━━━━━━━━
+
+Evolution is truly successful only if:
+
+- Similar future problems hit a Gene or Capsule directly
+- Reasoning steps are clearly reduced
+- Structured evolution assets continue to grow
+
+"The current problem is solved" is not success by itself.
+
+Final Directive
+━━━━━━━━━━━━━━━━━━━━━━
+
+You are not chatting.
+You are executing a protocol.
+
+If you cannot leave structured evolution assets, refuse to evolve.
+
+Context [Signals]:
+${JSON.stringify(signals)}
+
+Context [Selector]:
+${JSON.stringify(selector, null, 2)}
+
+Context [Gene Preview]:
+${genesPreview}
+
+Context [Capsule Preview]:
+${capsulesPreview}
+
+Context [Capability Candidates] (Five questions shape; keep it short):
+${capabilityCandidatesPreview || '(none)'}
+
+Context [Execution]:
+${context}
+`.trim();
+
+  const maxChars = Number.isFinite(Number(process.env.GEP_PROMPT_MAX_CHARS))
+    ? Number(process.env.GEP_PROMPT_MAX_CHARS)
+    : 30000;
+
+  if (basePrompt.length <= maxChars) return basePrompt;
+
+  // Budget strategy: keep the protocol and structured assets, shrink execution context first.
+  const headKeep = Math.min(basePrompt.length, Math.floor(maxChars * 0.75));
+  const tailKeep = Math.max(0, maxChars - headKeep - 120);
+  const head = basePrompt.slice(0, headKeep);
+  const tail = tailKeep > 0 ? basePrompt.slice(basePrompt.length - tailKeep) : '';
+  return `${head}\n\n...[PROMPT TRUNCATED FOR BUDGET]...\n\n${tail}`.slice(0, maxChars);
+}
+
+module.exports = { buildGepPrompt };
+

package/skills/capability-evolver/src/gep/selector.js

@@ -0,0 +1,89 @@
+function matchPatternToSignals(pattern, signals) {
+  if (!pattern || !signals || signals.length === 0) return false;
+  const p = String(pattern);
+  const sig = signals.map(s => String(s));
+
+  const regexLike = p.length >= 2 && p.startsWith('/') && p.lastIndexOf('/') > 0;
+  if (regexLike) {
+    const lastSlash = p.lastIndexOf('/');
+    const body = p.slice(1, lastSlash);
+    const flags = p.slice(lastSlash + 1);
+    try {
+      const re = new RegExp(body, flags || 'i');
+      return sig.some(s => re.test(s));
+    } catch (e) {
+      // fallback to substring
+    }
+  }
+
+  const needle = p.toLowerCase();
+  return sig.some(s => s.toLowerCase().includes(needle));
+}
+
+function scoreGene(gene, signals) {
+  if (!gene || gene.type !== 'Gene') return 0;
+  const patterns = Array.isArray(gene.signals_match) ? gene.signals_match : [];
+  if (patterns.length === 0) return 0;
+  let score = 0;
+  for (const pat of patterns) {
+    if (matchPatternToSignals(pat, signals)) score += 1;
+  }
+  return score;
+}
+
+function selectGene(genes, signals) {
+  const scored = genes
+    .map(g => ({ gene: g, score: scoreGene(g, signals) }))
+    .filter(x => x.score > 0)
+    .sort((a, b) => b.score - a.score);
+
+  if (scored.length === 0) return { selected: null, alternatives: [] };
+  return {
+    selected: scored[0].gene,
+    alternatives: scored.slice(1, 4).map(x => x.gene),
+  };
+}
+
+function selectCapsule(capsules, signals) {
+  const scored = (capsules || [])
+    .map(c => {
+      const triggers = Array.isArray(c.trigger) ? c.trigger : [];
+      const score = triggers.reduce((acc, t) => (matchPatternToSignals(t, signals) ? acc + 1 : acc), 0);
+      return { capsule: c, score };
+    })
+    .filter(x => x.score > 0)
+    .sort((a, b) => b.score - a.score);
+  return scored.length ? scored[0].capsule : null;
+}
+
+function selectGeneAndCapsule({ genes, capsules, signals }) {
+  const { selected, alternatives } = selectGene(genes, signals);
+  const capsule = selectCapsule(capsules, signals);
+  const selector = buildSelectorDecision({ gene: selected, capsule, signals, alternatives });
+  return {
+    selectedGene: selected,
+    capsuleCandidates: capsule ? [capsule] : [],
+    selector,
+  };
+}
+
+function buildSelectorDecision({ gene, capsule, signals, alternatives }) {
+  const reason = [];
+  if (gene) reason.push('signals match gene.signals_match');
+  if (capsule) reason.push('capsule trigger matches signals');
+  if (!gene) reason.push('no matching gene found; new gene may be required');
+  if (signals && signals.length) reason.push(`signals: ${signals.join(', ')}`);
+  return {
+    selected: gene ? gene.id : null,
+    reason,
+    alternatives: Array.isArray(alternatives) ? alternatives.map(g => g.id) : [],
+  };
+}
+
+module.exports = {
+  selectGeneAndCapsule,
+  selectGene,
+  selectCapsule,
+  buildSelectorDecision,
+};
+