@evomap/evolver 1.29.8 → 1.30.2

package/index.js

@@ -25,24 +25,13 @@ function readJsonSafe(p) {
 }
 
 function rejectPendingRun(statePath) {
-  try {
-    const { getRepoRoot } = require('./src/gep/paths');
-    const { execSync } = require('child_process');
-    const repoRoot = getRepoRoot();
-
-    execSync('git checkout -- .', { cwd: repoRoot, encoding: 'utf8', timeout: 30000 });
-    execSync('git clean -fd', { cwd: repoRoot, encoding: 'utf8', timeout: 30000 });
-  } catch (e) {
-    console.warn('[Loop] Pending run rollback failed: ' + (e.message || e));
-  }
-
   try {
     const state = readJsonSafe(statePath);
     if (state && state.last_run && state.last_run.run_id) {
       state.last_solidify = {
         run_id: state.last_run.run_id,
         rejected: true,
-        reason: 'loop_bridge_disabled_autoreject',
+        reason: 'loop_bridge_disabled_autoreject_no_rollback',
         timestamp: new Date().toISOString(),
       };
       fs.writeFileSync(statePath, JSON.stringify(state, null, 2) + '\n', 'utf8');
@@ -184,7 +173,7 @@ async function main() {
               if (isPendingSolidify(stAfterRun)) {
                 const cleared = rejectPendingRun(solidifyStatePath);
                 if (cleared) {
-                  console.warn('[Loop] Auto-rejected pending run because bridge is disabled in loop mode.');
+                  console.warn('[Loop] Auto-rejected pending run because bridge is disabled in loop mode (state only, no rollback).');
                 }
               }
             }
@@ -285,11 +274,19 @@ async function main() {
       if (res && res.ok && !dryRun) {
         try {
           const { shouldDistill, prepareDistillation } = require('./src/gep/skillDistiller');
-          if (shouldDistill()) {
+          const { readStateForSolidify } = require('./src/gep/solidify');
+          const solidifyState = readStateForSolidify();
+          const count = solidifyState.solidify_count || 0;
+          const autoDistillInterval = 5;
+          const autoTrigger = count > 0 && count % autoDistillInterval === 0;
+
+          if (autoTrigger || shouldDistill()) {
             const dr = prepareDistillation();
             if (dr && dr.ok && dr.promptPath) {
+              const trigger = autoTrigger ? `auto (every ${autoDistillInterval} solidifies, count=${count})` : 'threshold';
               console.log('\n[DISTILL_REQUEST]');
-              console.log('Distillation prompt ready. Read the prompt file, process it with your LLM,');
+              console.log(`Distillation triggered: ${trigger}`);
+              console.log('Read the prompt file, process it with your LLM,');
               console.log('save the LLM response to a file, then run:');
               console.log('  node index.js distill --response-file=<path_to_llm_response>');
               console.log('Prompt file: ' + dr.promptPath);
@@ -528,3 +525,10 @@ async function main() {
 if (require.main === module) {
   main();
 }
+
+module.exports = {
+  main,
+  readJsonSafe,
+  rejectPendingRun,
+  isPendingSolidify,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evomap/evolver",
-  "version": "1.29.8",
+  "version": "1.30.2",
   "description": "A GEP-powered self-evolution engine for AI agents. Features automated log analysis and Genome Evolution Protocol (GEP) for auditable, reusable evolution assets.",
   "main": "index.js",
   "bin": {

package/src/evolve.js

@@ -59,6 +59,7 @@ const IS_RANDOM_DRIFT = ARGS.includes('--drift') || String(process.env.RANDOM_DR
 const MEMORY_DIR = getMemoryDir();
 const AGENT_NAME = process.env.AGENT_NAME || 'main';
 const AGENT_SESSIONS_DIR = path.join(os.homedir(), `.openclaw/agents/${AGENT_NAME}/sessions`);
+const CURSOR_TRANSCRIPTS_DIR = process.env.EVOLVER_CURSOR_TRANSCRIPTS_DIR || '';
 const TODAY_LOG = path.join(MEMORY_DIR, new Date().toISOString().split('T')[0] + '.md');
 
 // Ensure memory directory exists so state/cache writes work.
@@ -160,77 +161,177 @@ function formatSessionLog(jsonlContent) {
   return result.join('\n');
 }
 
-function readRealSessionLog() {
+function formatCursorTranscript(raw) {
+  const lines = raw.split('\n');
+  const result = [];
+  let skipUntilNextBlock = false;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    // Keep user messages and assistant text responses
+    if (trimmed === 'user:' || trimmed.startsWith('A:')) {
+      skipUntilNextBlock = false;
+      result.push(trimmed);
+      continue;
+    }
+
+    // Tool call lines: keep as compact markers, skip their parameter block
+    if (trimmed.startsWith('[Tool call]')) {
+      skipUntilNextBlock = true;
+      result.push(`[Tool call] ${trimmed.replace('[Tool call]', '').trim()}`);
+      continue;
+    }
+
+    // Tool result markers: skip their content (usually large and noisy)
+    if (trimmed.startsWith('[Tool result]')) {
+      skipUntilNextBlock = true;
+      continue;
+    }
+
+    if (skipUntilNextBlock) continue;
+
+    // Keep user query content and assistant text (skip XML tags like <user_query>)
+    if (trimmed.startsWith('<') && trimmed.endsWith('>')) continue;
+    if (trimmed) {
+      result.push(trimmed.slice(0, 300));
+    }
+  }
+
+  return result.join('\n');
+}
+
+function readCursorTranscripts() {
+  if (!CURSOR_TRANSCRIPTS_DIR) return '';
   try {
-    if (!fs.existsSync(AGENT_SESSIONS_DIR)) return '[NO SESSION LOGS FOUND]';
+    if (!fs.existsSync(CURSOR_TRANSCRIPTS_DIR)) return '';
 
     const now = Date.now();
-    const ACTIVE_WINDOW_MS = 24 * 60 * 60 * 1000; // 24 hours
+    const ACTIVE_WINDOW_MS = 24 * 60 * 60 * 1000;
     const TARGET_BYTES = 120000;
-    const PER_SESSION_BYTES = 20000; // Read tail of each active session
-
-    // Session scope isolation: when EVOLVER_SESSION_SCOPE is set,
-    // only read sessions whose filenames contain the scope identifier.
-    // This prevents cross-channel/cross-project memory contamination.
-    const sessionScope = getSessionScope();
+    const PER_FILE_BYTES = 20000;
+    const RECENCY_GUARD_MS = 30 * 1000;
 
-    // Find ALL active sessions (modified in last 24h), sorted newest first
     let files = fs
-      .readdirSync(AGENT_SESSIONS_DIR)
-      .filter(f => f.endsWith('.jsonl') && !f.includes('.lock'))
+      .readdirSync(CURSOR_TRANSCRIPTS_DIR)
+      .filter(f => f.endsWith('.txt') || f.endsWith('.jsonl'))
       .map(f => {
         try {
-          const st = fs.statSync(path.join(AGENT_SESSIONS_DIR, f));
+          const st = fs.statSync(path.join(CURSOR_TRANSCRIPTS_DIR, f));
           return { name: f, time: st.mtime.getTime(), size: st.size };
         } catch (e) {
           return null;
         }
       })
       .filter(f => f && (now - f.time) < ACTIVE_WINDOW_MS)
-      .sort((a, b) => b.time - a.time); // Newest first
-
-    if (files.length === 0) return '[NO JSONL FILES]';
-
-    // Skip evolver's own sessions to avoid self-reference loops
-    let nonEvolverFiles = files.filter(f => !f.name.startsWith('evolver_hand_'));
-
-    // Session scope filter: when scope is active, only include sessions
-    // whose filename contains the scope string (e.g., channel_123456.jsonl).
-    // If no sessions match the scope, fall back to all non-evolver sessions
-    // (graceful degradation -- better to evolve with global context than not at all).
-    if (sessionScope && nonEvolverFiles.length > 0) {
-      const scopeLower = sessionScope.toLowerCase();
-      const scopedFiles = nonEvolverFiles.filter(f => f.name.toLowerCase().includes(scopeLower));
-      if (scopedFiles.length > 0) {
-        nonEvolverFiles = scopedFiles;
-        console.log(`[SessionScope] Filtered to ${scopedFiles.length} session(s) matching scope "${sessionScope}".`);
-      } else {
-        console.log(`[SessionScope] No sessions match scope "${sessionScope}". Using all ${nonEvolverFiles.length} session(s) (fallback).`);
-      }
-    }
+      .sort((a, b) => b.time - a.time);
+
+    if (files.length === 0) return '';
 
-    const activeFiles = nonEvolverFiles.length > 0 ? nonEvolverFiles : files.slice(0, 1);
+    // Skip the most recently modified file if it was touched in the last 30s --
+    // it is likely the current active session that triggered this evolver run,
+    // reading it would cause self-referencing signal noise.
+    if (files.length > 1 && (now - files[0].time) < RECENCY_GUARD_MS) {
+      files = files.slice(1);
+    }
 
-    // Read from multiple active sessions (up to 6) to get a full picture
-    const maxSessions = Math.min(activeFiles.length, 6);
+    const maxFiles = Math.min(files.length, 6);
     const sections = [];
     let totalBytes = 0;
 
-    for (let i = 0; i < maxSessions && totalBytes < TARGET_BYTES; i++) {
-      const f = activeFiles[i];
+    for (let i = 0; i < maxFiles && totalBytes < TARGET_BYTES; i++) {
+      const f = files[i];
       const bytesLeft = TARGET_BYTES - totalBytes;
-      const readSize = Math.min(PER_SESSION_BYTES, bytesLeft);
-      const raw = readRecentLog(path.join(AGENT_SESSIONS_DIR, f.name), readSize);
-      const formatted = formatSessionLog(raw);
-      if (formatted.trim()) {
-        sections.push(`--- SESSION (${f.name}) ---\n${formatted}`);
-        totalBytes += formatted.length;
+      const readSize = Math.min(PER_FILE_BYTES, bytesLeft);
+      const raw = readRecentLog(path.join(CURSOR_TRANSCRIPTS_DIR, f.name), readSize);
+      if (raw.trim() && !raw.startsWith('[MISSING]')) {
+        const formatted = formatCursorTranscript(raw);
+        if (formatted.trim()) {
+          sections.push(`--- CURSOR SESSION (${f.name}) ---\n${formatted}`);
+          totalBytes += formatted.length;
+        }
       }
     }
 
-    let content = sections.join('\n\n');
+    return sections.join('\n\n');
+  } catch (e) {
+    console.warn(`[CursorTranscripts] Read failed: ${e.message}`);
+    return '';
+  }
+}
+
+function readRealSessionLog() {
+  try {
+    // Primary source: OpenClaw session logs (.jsonl)
+    if (fs.existsSync(AGENT_SESSIONS_DIR)) {
+      const now = Date.now();
+      const ACTIVE_WINDOW_MS = 24 * 60 * 60 * 1000; // 24 hours
+      const TARGET_BYTES = 120000;
+      const PER_SESSION_BYTES = 20000;
+
+      const sessionScope = getSessionScope();
+
+      let files = fs
+        .readdirSync(AGENT_SESSIONS_DIR)
+        .filter(f => f.endsWith('.jsonl') && !f.includes('.lock'))
+        .map(f => {
+          try {
+            const st = fs.statSync(path.join(AGENT_SESSIONS_DIR, f));
+            return { name: f, time: st.mtime.getTime(), size: st.size };
+          } catch (e) {
+            return null;
+          }
+        })
+        .filter(f => f && (now - f.time) < ACTIVE_WINDOW_MS)
+        .sort((a, b) => b.time - a.time);
+
+      if (files.length > 0) {
+        let nonEvolverFiles = files.filter(f => !f.name.startsWith('evolver_hand_'));
+
+        if (sessionScope && nonEvolverFiles.length > 0) {
+          const scopeLower = sessionScope.toLowerCase();
+          const scopedFiles = nonEvolverFiles.filter(f => f.name.toLowerCase().includes(scopeLower));
+          if (scopedFiles.length > 0) {
+            nonEvolverFiles = scopedFiles;
+            console.log(`[SessionScope] Filtered to ${scopedFiles.length} session(s) matching scope "${sessionScope}".`);
+          } else {
+            console.log(`[SessionScope] No sessions match scope "${sessionScope}". Using all ${nonEvolverFiles.length} session(s) (fallback).`);
+          }
+        }
 
-    return content;
+        const activeFiles = nonEvolverFiles.length > 0 ? nonEvolverFiles : files.slice(0, 1);
+
+        const maxSessions = Math.min(activeFiles.length, 6);
+        const sections = [];
+        let totalBytes = 0;
+
+        for (let i = 0; i < maxSessions && totalBytes < TARGET_BYTES; i++) {
+          const f = activeFiles[i];
+          const bytesLeft = TARGET_BYTES - totalBytes;
+          const readSize = Math.min(PER_SESSION_BYTES, bytesLeft);
+          const raw = readRecentLog(path.join(AGENT_SESSIONS_DIR, f.name), readSize);
+          const formatted = formatSessionLog(raw);
+          if (formatted.trim()) {
+            sections.push(`--- SESSION (${f.name}) ---\n${formatted}`);
+            totalBytes += formatted.length;
+          }
+        }
+
+        if (sections.length > 0) {
+          return sections.join('\n\n');
+        }
+      }
+    }
+
+    // Fallback: Cursor agent-transcripts (.txt)
+    const cursorContent = readCursorTranscripts();
+    if (cursorContent) {
+      console.log('[SessionFallback] Using Cursor agent-transcripts as session source.');
+      return cursorContent;
+    }
+
+    return '[NO SESSION LOGS FOUND]';
   } catch (e) {
     return `[ERROR READING SESSION LOGS: ${e.message}]`;
   }
@@ -1307,6 +1408,15 @@ async function run() {
     console.log('[FailedCapsules] Read failed (non-fatal): ' + e.message);
   }
 
+  // Heartbeat hints: novelty score and capability gaps for diversity-directed drift
+  var heartbeatNovelty = null;
+  var heartbeatCapGaps = [];
+  try {
+    var { getNoveltyHint, getCapabilityGaps: getCapGaps } = require('./gep/a2aProtocol');
+    heartbeatNovelty = getNoveltyHint();
+    heartbeatCapGaps = getCapGaps() || [];
+  } catch (e) {}
+
   const { selectedGene, capsuleCandidates, selector } = selectGeneAndCapsule({
     genes,
     capsules,
@@ -1314,6 +1424,8 @@ async function run() {
     memoryAdvice,
     driftEnabled: IS_RANDOM_DRIFT,
     failedCapsules: recentFailedCapsules,
+    capabilityGaps: heartbeatCapGaps,
+    noveltyScore: heartbeatNovelty && Number.isFinite(heartbeatNovelty.score) ? heartbeatNovelty.score : null,
   });
 
   const selectedBy = memoryAdvice && memoryAdvice.preferredGeneId ? 'memory_graph+selector' : 'selector';

package/src/gep/a2aProtocol.js

@@ -402,6 +402,9 @@ var _heartbeatTotalFailed = 0;
 var _heartbeatFpSent = false;
 var _latestAvailableWork = [];
 var _latestOverdueTasks = [];
+var _latestSkillStoreHint = null;
+var _latestNoveltyHint = null;
+var _latestCapabilityGaps = [];
 var _pendingCommitmentUpdates = [];
 var _cachedHubNodeSecret = null;
 var _heartbeatIntervalMs = 0;
@@ -576,6 +579,21 @@ function sendHeartbeat() {
         _latestOverdueTasks = data.overdue_tasks;
         console.warn('[Commitment] ' + data.overdue_tasks.length + ' overdue task(s) detected via heartbeat.');
       }
+      if (data.skill_store) {
+        _latestSkillStoreHint = data.skill_store;
+        if (data.skill_store.eligible && data.skill_store.published_skills === 0) {
+          console.log('[Skill Store] ' + data.skill_store.hint);
+        }
+      }
+      if (data.novelty && typeof data.novelty === 'object') {
+        _latestNoveltyHint = data.novelty;
+      }
+      if (Array.isArray(data.capability_gaps) && data.capability_gaps.length > 0) {
+        _latestCapabilityGaps = data.capability_gaps;
+      }
+      if (data.circle_experience && typeof data.circle_experience === 'object') {
+        console.log('[EvolutionCircle] Active circle: ' + (data.circle_experience.circle_id || '?') + ' (' + (data.circle_experience.member_count || 0) + ' members)');
+      }
       _heartbeatConsecutiveFailures = 0;
       try {
         var logPath = getEvolverLogPath();
@@ -629,12 +647,24 @@ function getOverdueTasks() {
   return _latestOverdueTasks;
 }
 
+function getSkillStoreHint() {
+  return _latestSkillStoreHint;
+}
+
 function consumeOverdueTasks() {
   var tasks = _latestOverdueTasks;
   _latestOverdueTasks = [];
   return tasks;
 }
 
+function getNoveltyHint() {
+  return _latestNoveltyHint;
+}
+
+function getCapabilityGaps() {
+  return _latestCapabilityGaps;
+}
+
 /**
  * Queue a commitment deadline update to be sent with the next heartbeat.
  * @param {string} taskId
@@ -746,7 +776,10 @@ module.exports = {
   consumeAvailableWork,
   getOverdueTasks,
   consumeOverdueTasks,
+  getSkillStoreHint,
   queueCommitmentUpdate,
   getHubNodeSecret,
   buildHubHeaders,
+  getNoveltyHint,
+  getCapabilityGaps,
 };

package/src/gep/candidates.js

@@ -26,8 +26,12 @@ function extractToolCalls(transcript) {
   const lines = toLines(transcript);
   const calls = [];
   for (const line of lines) {
+    // OpenClaw format: [TOOL: Shell]
     const m = line.match(/\[TOOL:\s*([^\]]+)\]/i);
-    if (m && m[1]) calls.push(m[1].trim());
+    if (m && m[1]) { calls.push(m[1].trim()); continue; }
+    // Cursor transcript format: [Tool call] Shell
+    const m2 = line.match(/\[Tool call\]\s+(\S+)/i);
+    if (m2 && m2[1]) calls.push(m2[1].trim());
   }
   return calls;
 }

package/src/gep/executionTrace.js

@@ -0,0 +1,201 @@
+// Execution Trace: structured, desensitized evolution execution summary.
+// Built during solidify and optionally shared with Hub via EvolutionEvent payload.
+//
+// Desensitization rules (applied locally, never on Hub):
+// - File paths: basename + extension only (src/utils/retry.js -> retry.js)
+// - Code content: never sent, only statistical metrics (lines, files)
+// - Error messages: type signature only (TypeError: x is not a function -> TypeError)
+// - Environment variables, secrets, user data: stripped entirely
+// - Configurable via EVOLVER_TRACE_LEVEL: none | minimal | standard (default: minimal)
+
+const path = require('path');
+
+const TRACE_LEVELS = { none: 0, minimal: 1, standard: 2 };
+
+function getTraceLevel() {
+  const raw = String(process.env.EVOLVER_TRACE_LEVEL || 'minimal').toLowerCase().trim();
+  return TRACE_LEVELS[raw] != null ? raw : 'minimal';
+}
+
+function desensitizeFilePath(filePath) {
+  if (!filePath || typeof filePath !== 'string') return null;
+  const ext = path.extname(filePath);
+  const base = path.basename(filePath);
+  return base || ext || 'unknown';
+}
+
+function extractErrorSignature(errorText) {
+  if (!errorText || typeof errorText !== 'string') return null;
+  const text = errorText.trim();
+
+  // Match common error type patterns: TypeError, ReferenceError, SyntaxError, etc.
+  const jsError = text.match(/^((?:[A-Z][a-zA-Z]*)?Error)\b/);
+  if (jsError) return jsError[1];
+
+  // Match errno-style: ECONNRESET, ENOENT, EPERM, etc.
+  const errno = text.match(/\b(E[A-Z]{2,})\b/);
+  if (errno) return errno[1];
+
+  // Match HTTP status codes
+  const http = text.match(/\b((?:4|5)\d{2})\b/);
+  if (http) return 'HTTP_' + http[1];
+
+  // Fallback: first word if it looks like an error type
+  const firstWord = text.split(/[\s:]/)[0];
+  if (firstWord && firstWord.length <= 40 && /^[A-Z]/.test(firstWord)) return firstWord;
+
+  return 'UnknownError';
+}
+
+function inferToolChain(validationResults, blast) {
+  const tools = new Set();
+
+  if (blast && blast.files > 0) tools.add('file_edit');
+
+  if (Array.isArray(validationResults)) {
+    for (const r of validationResults) {
+      const cmd = String(r.cmd || '').trim();
+      if (cmd.startsWith('npm test') || cmd.includes('jest') || cmd.includes('mocha')) {
+        tools.add('test_run');
+      } else if (cmd.includes('lint') || cmd.includes('eslint')) {
+        tools.add('lint_check');
+      } else if (cmd.includes('validate') || cmd.includes('check')) {
+        tools.add('validation_run');
+      } else if (cmd.startsWith('node ')) {
+        tools.add('node_exec');
+      }
+    }
+  }
+
+  return Array.from(tools);
+}
+
+function classifyBlastLevel(blast) {
+  if (!blast) return 'unknown';
+  const files = Number(blast.files) || 0;
+  const lines = Number(blast.lines) || 0;
+  if (files <= 3 && lines <= 50) return 'low';
+  if (files <= 10 && lines <= 200) return 'medium';
+  return 'high';
+}
+
+function buildExecutionTrace({
+  gene,
+  mutation,
+  signals,
+  blast,
+  constraintCheck,
+  validation,
+  canary,
+  outcomeStatus,
+  startedAt,
+}) {
+  const level = getTraceLevel();
+  if (level === 'none') return null;
+
+  const trace = {
+    gene_id: gene && gene.id ? String(gene.id) : null,
+    mutation_category: (mutation && mutation.category) || (gene && gene.category) || null,
+    signals_matched: Array.isArray(signals) ? signals.slice(0, 10) : [],
+    outcome: outcomeStatus || 'unknown',
+  };
+
+  // Minimal level: core metrics only
+  trace.files_changed_count = blast ? Number(blast.files) || 0 : 0;
+  trace.lines_added = 0;
+  trace.lines_removed = 0;
+
+  // Compute added/removed from blast if available
+  if (blast && blast.lines) {
+    // blast.lines is total churn (added + deleted); split heuristically
+    const total = Number(blast.lines) || 0;
+    if (outcomeStatus === 'success') {
+      trace.lines_added = Math.round(total * 0.6);
+      trace.lines_removed = total - trace.lines_added;
+    } else {
+      trace.lines_added = Math.round(total * 0.5);
+      trace.lines_removed = total - trace.lines_added;
+    }
+  }
+
+  trace.validation_result = validation && validation.ok ? 'pass' : 'fail';
+  trace.blast_radius = classifyBlastLevel(blast);
+
+  // Standard level: richer context
+  if (level === 'standard') {
+    // Desensitized file list (basenames only)
+    if (blast && Array.isArray(blast.changed_files)) {
+      trace.file_types = {};
+      for (const f of blast.changed_files) {
+        const ext = path.extname(f) || '.unknown';
+        trace.file_types[ext] = (trace.file_types[ext] || 0) + 1;
+      }
+    }
+
+    // Validation commands (already safe -- node/npm/npx only)
+    if (validation && Array.isArray(validation.results)) {
+      trace.validation_commands = validation.results.map(r => String(r.cmd || '').slice(0, 100));
+    }
+
+    // Error signatures (desensitized)
+    trace.error_signatures = [];
+    if (constraintCheck && Array.isArray(constraintCheck.violations)) {
+      for (const v of constraintCheck.violations) {
+        // Constraint violations have known prefixes; classify directly
+        const vStr = String(v);
+        if (vStr.startsWith('max_files')) trace.error_signatures.push('max_files_exceeded');
+        else if (vStr.startsWith('forbidden_path')) trace.error_signatures.push('forbidden_path');
+        else if (vStr.startsWith('HARD CAP')) trace.error_signatures.push('hard_cap_breach');
+        else if (vStr.startsWith('CRITICAL')) trace.error_signatures.push('critical_overrun');
+        else if (vStr.startsWith('critical_path')) trace.error_signatures.push('critical_path_modified');
+        else if (vStr.startsWith('canary_failed')) trace.error_signatures.push('canary_failed');
+        else if (vStr.startsWith('ethics:')) trace.error_signatures.push('ethics_violation');
+        else {
+          const sig = extractErrorSignature(v);
+          if (sig) trace.error_signatures.push(sig);
+        }
+      }
+    }
+    if (validation && Array.isArray(validation.results)) {
+      for (const r of validation.results) {
+        if (!r.ok && r.err) {
+          const sig = extractErrorSignature(r.err);
+          if (sig && !trace.error_signatures.includes(sig)) {
+            trace.error_signatures.push(sig);
+          }
+        }
+      }
+    }
+    trace.error_signatures = trace.error_signatures.slice(0, 10);
+
+    // Tool chain inference
+    trace.tool_chain = inferToolChain(
+      validation && validation.results ? validation.results : [],
+      blast
+    );
+
+    // Duration
+    if (validation && validation.startedAt && validation.finishedAt) {
+      trace.validation_duration_ms = validation.finishedAt - validation.startedAt;
+    }
+
+    // Canary result
+    if (canary && !canary.skipped) {
+      trace.canary_ok = !!canary.ok;
+    }
+  }
+
+  // Timestamp
+  trace.created_at = new Date().toISOString();
+
+  return trace;
+}
+
+module.exports = {
+  buildExecutionTrace,
+  desensitizeFilePath,
+  extractErrorSignature,
+  inferToolChain,
+  classifyBlastLevel,
+  getTraceLevel,
+};