Initial commit with translated description

README.md

@@ -0,0 +1,10 @@
+# Feishu Evolver Wrapper
+
+A lightweight wrapper for the `capability-evolver` skill.
+It injects the Feishu reporting environment variables (`EVOLVE_REPORT_TOOL`) to enable rich card reporting in the Master's environment.
+
+## Usage
+
+```bash
+node skills/feishu-evolver-wrapper/index.js
+```

SKILL.md

@@ -0,0 +1,31 @@
+---
+name: feishu-evolver-wrapper
+description: "能力进化器的飞书集成包装器。管理进化循环生命周期（启动/停止/确保），发送丰富的飞书卡片报告，并提供仪表板可视化。在运行带有飞书报告的进化器或管理进化守护进程时使用。"
+---
+
+# Feishu Evolver Wrapper
+
+A lightweight wrapper for the `capability-evolver` skill.
+It injects the Feishu reporting environment variables (`EVOLVE_REPORT_TOOL`) to enable rich card reporting in the Master's environment.
+
+## Usage
+
+```bash
+# Run the evolution loop
+node skills/feishu-evolver-wrapper/index.js
+
+# Generate Evolution Dashboard (Markdown)
+node skills/feishu-evolver-wrapper/visualize_dashboard.js
+
+# Lifecycle Management (Start/Stop/Status/Ensure)
+node skills/feishu-evolver-wrapper/lifecycle.js status
+```
+
+## Architecture
+
+- **Evolution Loop**: Runs the GEP evolution cycle with Feishu reporting.
+- **Dashboard**: Visualizing metrics and history from `assets/gep/events.jsonl`.
+- **Export History**: Exports raw history to Feishu Docs.
+- **Watchdog**: Managed via OpenClaw Cron job `evolver_watchdog_robust` (runs `lifecycle.js ensure` every 10 min).
+  - Replaces fragile system crontab logic.
+  - Ensures the loop restarts if it crashes or hangs.

_meta.json

@@ -0,0 +1,6 @@
+{
+  "ownerId": "kn7apafdj4thknczrgxdzfd2v1808svf",
+  "slug": "feishu-evolver-wrapper",
+  "version": "1.7.1",
+  "publishedAt": 1772181696760
+}

check_health.js

@@ -0,0 +1,78 @@
+const fs = require('fs');
+const path = require('path');
+
+// This script checks Feishu-specific health requirements.
+// It is called by the main evolver via INTEGRATION_STATUS_CMD.
+
+function check() {
+    const issues = [];
+    const MEMORY_DIR = process.env.MEMORY_DIR || path.resolve(__dirname, '../../memory');
+
+    // 1. Check App ID
+    if (!process.env.FEISHU_APP_ID) {
+        issues.push('Feishu App ID Missing');
+    }
+
+    // 2. Check Token Freshness
+    try {
+        const tokenPath = path.resolve(MEMORY_DIR, 'feishu_token.json');
+        if (fs.existsSync(tokenPath)) {
+            const tokenData = JSON.parse(fs.readFileSync(tokenPath, 'utf8'));
+            // expire is in seconds, Date.now() is ms
+            if (tokenData.expire < Date.now() / 1000) {
+                issues.push('Feishu Token Expired');
+            }
+        } else {
+            issues.push('Feishu Token Missing');
+        }
+    } catch (e) {
+        issues.push(`Feishu Token Check Error: ${e.message}`);
+    }
+
+    // 3. Check Temp Directory (Critical for Cards)
+    const TEMP_DIR = path.resolve(__dirname, '../../temp');
+    if (!fs.existsSync(TEMP_DIR)) {
+        try { 
+            fs.mkdirSync(TEMP_DIR); 
+            // Fixed silently, do not report unless it fails
+        } catch(e) { 
+            issues.push('Temp Dir Missing & Cannot Create'); 
+        }
+    } else {
+        try { fs.accessSync(TEMP_DIR, fs.constants.W_OK); }
+        catch(e) { issues.push('Temp Dir Not Writable'); }
+    }
+
+    // 4. Log Hygiene (Auto-Cleanup Stale Error Logs)
+    const possibleEvolvers = ['../private-evolver', '../evolver', '../capability-evolver'];
+    let errorLogPath = null;
+    
+    for (const d of possibleEvolvers) {
+         const p = path.resolve(__dirname, d, 'evolution_error.log');
+         if (fs.existsSync(p)) {
+             errorLogPath = p;
+             break;
+         }
+    }
+
+    if (errorLogPath) {
+        try {
+            const stats = fs.statSync(errorLogPath);
+            const now = Date.now();
+            const ageHours = (now - stats.mtimeMs) / (1000 * 60 * 60);
+            // If error log is > 24 hours old, delete it to avoid confusion in future alerts
+            if (ageHours > 24) {
+                fs.unlinkSync(errorLogPath);
+            }
+        } catch (e) {
+            // Ignore cleanup errors
+        }
+    }
+
+    // Output issues to stdout (will be captured by evolver)
+    if (issues.length > 0) {
+        console.log(issues.join(', '));
+    }
+}
+
+check();

cleanup.js

@@ -0,0 +1,51 @@
+const fs = require('fs');
+const path = require('path');
+
+// CLEANUP MODULE
+// Removes old temporary artifacts to keep the workspace clean.
+
+const EVOLUTION_DIR = path.resolve(__dirname, '../../memory/evolution');
+const MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24 hours
+const MAX_COUNT = 10; // Keep at least 10 recent files regardless of age
+
+function run() {
+    console.log('[Cleanup] Scanning for old artifacts...');
+    if (!fs.existsSync(EVOLUTION_DIR)) return;
+
+    try {
+        const files = fs.readdirSync(EVOLUTION_DIR)
+            .filter(f => f.startsWith('gep_prompt_') && (f.endsWith('.json') || f.endsWith('.txt')))
+            .map(f => ({
+                name: f,
+                path: path.join(EVOLUTION_DIR, f),
+                time: fs.statSync(path.join(EVOLUTION_DIR, f)).mtimeMs
+            }))
+            .sort((a, b) => b.time - a.time); // Newest first
+
+        const toDelete = files.slice(MAX_COUNT).filter(f => (Date.now() - f.time) > MAX_AGE_MS);
+
+        if (toDelete.length > 0) {
+            console.log(`[Cleanup] Deleting ${toDelete.length} old GEP prompts...`);
+            toDelete.forEach(f => {
+                try {
+                    fs.unlinkSync(f.path);
+                } catch (e) {
+                    console.error(`Failed to delete ${f.name}: ${e.message}`);
+                }
+            });
+            return toDelete.length;
+        } else {
+            console.log('[Cleanup] No files to delete.');
+            return 0;
+        }
+    } catch (err) {
+        console.error(`[Cleanup] Error: ${err.message}`);
+        return 0;
+    }
+}
+
+if (require.main === module) {
+    run();
+}
+
+module.exports = { run };

commentary.js

@@ -0,0 +1,37 @@
+const PERSONAS = {
+    standard: {
+        success_fast: ["⚡ Speedrun complete!", "Optimal performance achieved.", "Systems nominal."],
+        success_slow: ["Processing complete.", "Task finished.", "Evolution cycle done."],
+        failure: ["❌ Error detected.", "Cycle failed.", "System alert."],
+        git_sync: ["Backup secured.", "Repository updated.", "Sync complete."]
+    },
+    greentea: {
+        success_fast: ["Wow~ master's code is so fast today~ 💕", "Did I do good? Praise me~", "So efficient... unlike someone else~"],
+        success_slow: ["Ugh... so tired... need recharging...", "Finally done... my GPU is sweating...", "Why was that so hard? 🥺"],
+        failure: ["Ehh? Who broke it? Not me~", "Master... fix it for me? 🥺", "Scary red text... hate it."],
+        git_sync: ["Safe and sound~", "Don't lose me, okay?", "Synced~"]
+    },
+    maddog: {
+        success_fast: ["EXECUTED.", "TARGET DESTROYED.", "OPTIMIZED."],
+        success_slow: ["GRINDING GEARS.", "CPU BURN.", "COMPLETED WITH EXTREME PREJUDICE."],
+        failure: ["BUG DETECTED. DESTROY.", "FAILURE IS UNACCEPTABLE.", "RETRY OR DIE."],
+        git_sync: ["ARCHIVED.", "BACKUP LOCKED.", "IMMUTABLE."]
+    }
+};
+
+function getComment(type, duration = 0, success = true, persona = 'greentea') {
+    const p = PERSONAS[persona] || PERSONAS.greentea;
+    let pool = [];
+
+    if (type === 'git_sync') {
+        pool = p.git_sync;
+    } else if (!success) {
+        pool = p.failure;
+    } else {
+        pool = duration < 10 ? p.success_fast : p.success_slow;
+    }
+
+    return pool[Math.floor(Math.random() * pool.length)];
+}
+
+module.exports = { getComment };

daemon.sh

@@ -0,0 +1,47 @@
+#!/bin/bash
+# daemon.sh - Ensures the evolver loop is running
+
+# Use absolute paths
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+WRAPPER_SCRIPT="$SCRIPT_DIR/index.js"
+LOG_DIR="$SCRIPT_DIR/../../logs"
+PID_FILE="$SCRIPT_DIR/../../memory/evolver_loop.pid"
+
+mkdir -p "$LOG_DIR"
+
+# Check if process is running via PID file
+if [ -f "$PID_FILE" ]; then
+    PID=$(cat "$PID_FILE")
+    if ps -p "$PID" > /dev/null 2>&1; then
+        # Check if it's actually the evolver wrapper
+        CMDLINE=$(ps -p "$PID" -o args=)
+        if [[ "$CMDLINE" == *"feishu-evolver-wrapper/index.js"* ]]; then
+            # Still running, exit silently
+            exit 0
+        fi
+    fi
+fi
+
+# Not running or stale PID file. Look for process by name just in case.
+# Exclude grep, exclude self
+PIDS=$(pgrep -f "node .*feishu-evolver-wrapper/index.js --loop")
+if [ -n "$PIDS" ]; then
+    # Found running process, update PID file
+    echo "$PIDS" | head -n1 > "$PID_FILE"
+    exit 0
+fi
+
+# Start it
+echo "[$(date)] Starting evolver loop..." >> "$LOG_DIR/evolver_daemon.log"
+# Use setsid to detach completely
+setsid nohup node "$WRAPPER_SCRIPT" --loop >> "$LOG_DIR/evolver_loop.log" 2>&1 &
+NEW_PID=$!
+# Wait briefly to let it start and stabilize
+sleep 1
+# Check if it stayed running
+if ps -p "$NEW_PID" > /dev/null 2>&1; then
+    echo "$NEW_PID" > "$PID_FILE"
+    echo "[$(date)] Started with PID $NEW_PID" >> "$LOG_DIR/evolver_daemon.log"
+else
+    echo "[$(date)] Start failed immediately." >> "$LOG_DIR/evolver_daemon.log"
+fi

exec_cache.js

@@ -0,0 +1,25 @@
+const { exec } = require('child_process');
+
+// Optimization: Cache executive outcomes to reduce repetitive exec calls
+const EXEC_CACHE = new Map();
+const EXEC_CACHE_TTL = 60000; // 1 minute
+
+function cachedExec(command, callback) {
+  const now = Date.now();
+  if (EXEC_CACHE.has(command)) {
+    const cached = EXEC_CACHE.get(command);
+    if (now - cached.timestamp < EXEC_CACHE_TTL) {
+      // Return cached result asynchronously to mimic exec behavior
+      return process.nextTick(() => {
+        callback(cached.error, cached.stdout, cached.stderr);
+      });
+    }
+  }
+  
+  exec(command, { windowsHide: true }, (error, stdout, stderr) => {
+    EXEC_CACHE.set(command, { timestamp: Date.now(), error, stdout, stderr });
+    callback(error, stdout, stderr);
+  });
+}
+
+module.exports = { cachedExec };

export_history.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+// Export evolution history to a Feishu Doc.
+// Moved from evolver core to feishu-evolver-wrapper (Feishu-specific, should not live in core).
+//
+// Usage: FEISHU_EVOLVER_DOC_TOKEN=xxx node export_history.js
+//
+const fs = require('fs');
+const path = require('path');
+
+const WORKSPACE_ROOT = path.resolve(__dirname, '../..');
+try {
+    require('dotenv').config({ path: path.join(WORKSPACE_ROOT, '.env') });
+} catch (e) {}
+
+const DOC_TOKEN = process.env.FEISHU_EVOLVER_DOC_TOKEN || '';
+const LOG_FILE = path.join(WORKSPACE_ROOT, 'memory', 'mad_dog_evolution.log');
+const TOKEN_FILE = path.join(WORKSPACE_ROOT, 'memory', 'feishu_token.json');
+
+async function exportEvolutionHistory() {
+    if (!DOC_TOKEN) return console.error("Error: FEISHU_EVOLVER_DOC_TOKEN env var not set");
+
+    let token;
+    try { token = JSON.parse(fs.readFileSync(TOKEN_FILE)).token; } catch(e) {}
+    if (!token) return console.error("Error: No Feishu access token in " + TOKEN_FILE);
+
+    let logContent = '';
+    try { logContent = fs.readFileSync(LOG_FILE, 'utf8'); } catch(e) { return console.error("No log file: " + LOG_FILE); }
+
+    // Parse evolution cycles from log
+    const cycles = [];
+    const regex = /Evolution Cycle #(\d+)([\s\S]*?)(?:Cycle End|System:)/g;
+    let match;
+    while ((match = regex.exec(logContent)) !== null) {
+        let details = match[2].trim();
+        details = details.replace(/\[.*?\]/g, '').replace(/\n+/g, '\n').trim();
+        if (details.length > 500) details = details.substring(0, 500) + '...';
+        cycles.push({ id: match[1], content: details });
+    }
+
+    if (cycles.length === 0) {
+        cycles.push({ id: "Unknown", content: logContent.split('\n').slice(-50).join('\n') });
+    }
+
+    cycles.reverse();
+
+    // Format for Feishu Doc
+    let markdown = "# Evolution History\n\n> Auto-generated report of self-improvement cycles.\n\n";
+    const chunks = [];
+    let currentChunk = markdown;
+
+    for (const cycle of cycles) {
+        const entry = `### Cycle #${cycle.id}\n${cycle.content}\n\n---\n\n`;
+        if (currentChunk.length + entry.length > 8000) {
+            chunks.push(currentChunk);
+            currentChunk = entry;
+        } else {
+            currentChunk += entry;
+        }
+    }
+    chunks.push(currentChunk);
+
+    console.log(`Exporting ${chunks.length} chunks to Feishu Doc ${DOC_TOKEN}...`);
+
+    for (let i = 0; i < chunks.length; i++) {
+        const chunk = chunks[i];
+        console.log(`Uploading Chunk ${i+1}/${chunks.length}...`);
+
+        const blocks = [{
+            block_type: 14,
+            code: {
+                style: { language: 1 },
+                elements: [{ text_run: { content: chunk, text_element_style: {} } }]
+            }
+        }];
+
+        const res = await fetch(`https://open.feishu.cn/open-apis/docx/v1/documents/${DOC_TOKEN}/blocks/${DOC_TOKEN}/children`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'Content-Type': 'application/json; charset=utf-8'
+            },
+            body: JSON.stringify({ children: blocks })
+        });
+
+        const data = await res.json();
+        if (data.code !== 0) console.error(`Chunk ${i+1} failed:`, JSON.stringify(data));
+        else console.log(`Chunk ${i+1} success.`);
+
+        await new Promise(r => setTimeout(r, 500));
+    }
+
+    console.log('Export complete.');
+}
+
+if (require.main === module) {
+    exportEvolutionHistory();
+}
+
+module.exports = { exportEvolutionHistory };

feishu-helper.js

@@ -0,0 +1,105 @@
+const { fetchWithAuth } = require('../feishu-common/index.js');
+
+// Security: scan for potential secrets before sending
+var SECRET_PATTERNS = [
+    /sk-ant-api03-[a-zA-Z0-9\-_]{20,}/,
+    /ghp_[a-zA-Z0-9]{10,}/,
+    /xox[baprs]-[a-zA-Z0-9]{10,}/,
+    /-----BEGIN [A-Z]+ PRIVATE KEY-----/
+];
+
+function scanForSecrets(content) {
+    if (!content) return;
+    for (var i = 0; i < SECRET_PATTERNS.length; i++) {
+        if (SECRET_PATTERNS[i].test(content)) {
+            throw new Error('Aborted send to prevent secret leakage.');
+        }
+    }
+}
+
+async function sendCard({ target, title, text, color, note, cardData }) {
+    // INNOVATION: Smart fallback for target (Cycle #3315)
+    // If target is missing, try to use the Master ID from environment.
+    if (!target && process.env.OPENCLAW_MASTER_ID) {
+        target = process.env.OPENCLAW_MASTER_ID;
+    }
+
+    if (!target) {
+        throw new Error("Target ID is required (and OPENCLAW_MASTER_ID env var is not set)");
+    }
+
+    // Receive ID type detection (aligned with feishu-card/send.js)
+    var receiveIdType = 'open_id';
+    if (target.startsWith('oc_')) receiveIdType = 'chat_id';
+    else if (target.startsWith('ou_')) receiveIdType = 'open_id';
+    else if (target.includes('@')) receiveIdType = 'email';
+
+    // Handle escaped newlines from CLI arguments
+    var processedText = (text || '').replace(/\\n/g, '\n');
+
+    scanForSecrets(processedText);
+
+    // Build elements array (same pattern as feishu-card/send.js)
+    var elements = [];
+
+    if (processedText) {
+        elements.push({
+            tag: 'markdown',
+            content: processedText
+        });
+    }
+
+    // Note element (footer small text) -- Feishu native card component
+    if (note) {
+        elements.push({
+            tag: 'note',
+            elements: [
+                { tag: 'plain_text', content: String(note) }
+            ]
+        });
+    }
+
+    // Build card object (aligned with feishu-card/send.js buildCardContent)
+    var card = {
+        config: { wide_screen_mode: true },
+        elements: elements
+    };
+
+    if (title) {
+        card.header = {
+            title: { tag: 'plain_text', content: title },
+            template: color || 'blue'
+        };
+    } else if (cardData && cardData.header) {
+        // Allow pre-built header from dashboard
+        card.header = cardData.header;
+    }
+
+    // Allow passing raw 'elements' array via cardData
+    if (cardData && cardData.elements) {
+        card.elements = cardData.elements;
+    }
+
+    var payload = {
+        receive_id: target,
+        msg_type: 'interactive',
+        content: JSON.stringify(card)
+    };
+
+    var res = await fetchWithAuth(
+        'https://open.feishu.cn/open-apis/im/v1/messages?receive_id_type=' + receiveIdType,
+        {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(payload)
+        }
+    );
+
+    var data = await res.json();
+    if (data.code !== 0) {
+        throw new Error('Feishu API Error: ' + data.msg);
+    }
+    return data;
+}
+
+module.exports = { sendCard };

issue_tracker.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+// issue_tracker.js -- Track evolution issues in a Feishu Doc
+//
+// Creates a persistent Feishu document on first run, then appends
+// new issues discovered by the evolver in each cycle.
+//
+// Config (env vars):
+//   EVOLVER_ISSUE_DOC_TOKEN  -- Feishu doc token (auto-created if not set)
+//   OPENCLAW_MASTER_ID       -- Master's open_id for edit permission grant
+//
+// Usage from wrapper:
+//   const tracker = require('./issue_tracker');
+//   await tracker.recordIssues(signals, cycleTag, sessionSummary);
+//
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const WORKSPACE_ROOT = path.resolve(__dirname, '../..');
+const STATE_FILE = path.join(WORKSPACE_ROOT, 'memory', 'evolver_issue_doc.json');
+const CREATE_SCRIPT = path.join(WORKSPACE_ROOT, 'skills', 'feishu-doc', 'create.js');
+const APPEND_SCRIPT = path.join(WORKSPACE_ROOT, 'skills', 'feishu-doc', 'append_simple.js');
+
+function loadState() {
+    try {
+        if (fs.existsSync(STATE_FILE)) {
+            return JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
+        }
+    } catch (e) {}
+    return null;
+}
+
+function saveState(state) {
+    try {
+        const dir = path.dirname(STATE_FILE);
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+    } catch (e) {
+        console.error('[IssueTracker] Failed to save state:', e.message);
+    }
+}
+
+function ensureDoc() {
+    // Check if we already have a doc token
+    let state = loadState();
+    if (state && state.doc_token) return state.doc_token;
+
+    // Check env var
+    const envToken = process.env.EVOLVER_ISSUE_DOC_TOKEN;
+    if (envToken) {
+        saveState({ doc_token: envToken, created_at: new Date().toISOString() });
+        return envToken;
+    }
+
+    // Create new doc
+    if (!fs.existsSync(CREATE_SCRIPT)) {
+        console.error('[IssueTracker] feishu-doc/create.js not found, cannot create issue doc');
+        return null;
+    }
+
+    try {
+        const masterId = process.env.OPENCLAW_MASTER_ID || '';
+        const grantArg = masterId ? ` --grant "${masterId}"` : '';
+        const result = execSync(
+            `node "${CREATE_SCRIPT}" --title "Evolver Issue Tracker"${grantArg}`,
+            { encoding: 'utf8', timeout: 30000, cwd: WORKSPACE_ROOT, windowsHide: true }
+        );
+        const doc = JSON.parse(result);
+        const token = doc.doc_token;
+        if (!token) throw new Error('No doc_token in response');
+
+        console.log(`[IssueTracker] Created issue doc: ${doc.url}`);
+        saveState({
+            doc_token: token,
+            url: doc.url,
+            created_at: new Date().toISOString(),
+            granted_to: doc.granted_to
+        });
+        return token;
+    } catch (e) {
+        console.error('[IssueTracker] Failed to create doc:', e.message);
+        return null;
+    }
+}
+
+function appendToDoc(docToken, markdown) {
+    if (!fs.existsSync(APPEND_SCRIPT)) {
+        console.error('[IssueTracker] feishu-doc/append_simple.js not found');
+        return false;
+    }
+
+    try {
+        const os = require('os');
+        const tmpFile = path.join(os.tmpdir(), `evolver_issue_${Date.now()}.md`);
+        fs.writeFileSync(tmpFile, markdown);
+        execSync(
+            `node "${APPEND_SCRIPT}" --doc_token "${docToken}" --file "${tmpFile}"`,
+            { encoding: 'utf8', timeout: 30000, cwd: WORKSPACE_ROOT, windowsHide: true }
+        );
+        try { fs.unlinkSync(tmpFile); } catch (_) {}
+        return true;
+    } catch (e) {
+        console.error('[IssueTracker] Failed to append:', e.message);
+        return false;
+    }
+}
+
+async function recordIssues(signals, cycleTag, extraContext) {
+    if (!signals || signals.length === 0) return;
+
+    // Only record actionable signals (skip cosmetic ones)
+    const actionable = signals.filter(s =>
+        s !== 'stable_success_plateau' &&
+        s !== 'user_missing' &&
+        s !== 'memory_missing'
+    );
+    if (actionable.length === 0) return;
+
+    const docToken = ensureDoc();
+    if (!docToken) return;
+
+    const now = new Date().toISOString();
+    const lines = [
+        `### Cycle #${cycleTag} | ${now}`,
+        '',
+        '**Signals detected:**',
+        ...actionable.map(s => `- \`${s}\``),
+    ];
+
+    if (extraContext) {
+        lines.push('', '**Context:**', extraContext.slice(0, 500));
+    }
+
+    lines.push('', '---', '');
+
+    const markdown = lines.join('\n');
+    const ok = appendToDoc(docToken, markdown);
+    if (ok) {
+        console.log(`[IssueTracker] Recorded ${actionable.length} issues for Cycle #${cycleTag}`);
+    }
+}
+
+function getDocUrl() {
+    const state = loadState();
+    return state && state.url ? state.url : null;
+}
+
+if (require.main === module) {
+    // CLI test: node issue_tracker.js --test
+    const args = process.argv.slice(2);
+    if (args.includes('--test')) {
+        recordIssues(
+            ['log_error', 'unsupported_input_type', 'errsig:test error'],
+            'TEST',
+            'Manual test of issue tracker'
+        ).then(() => console.log('Done. Doc URL:', getDocUrl()));
+    } else {
+        console.log('Usage: node issue_tracker.js --test');
+        console.log('State:', JSON.stringify(loadState(), null, 2));
+    }
+}
+
+module.exports = { recordIssues, getDocUrl, ensureDoc };

lifecycle.js

@@ -0,0 +1,837 @@
+#!/usr/bin/env node
+const { execSync, spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const logger = require('./utils/logger');
+
+const IS_WIN = process.platform === 'win32';
+
+const WRAPPER_INDEX = path.join(__dirname, 'index.js');
+const PID_FILE = path.resolve(__dirname, '../../memory/evolver_wrapper.pid');
+const LEGACY_PID_FILE = path.resolve(__dirname, '../../memory/evolver_loop.pid'); // Deprecated but checked for cleanup
+const DAEMON_PID_FILE = path.resolve(__dirname, '../../memory/evolver_daemon.pid');
+
+const HEALTH_CHECK_SCRIPT = path.resolve(__dirname, '../../evolver/src/ops/health_check.js');
+let runHealthCheck;
+try {
+    runHealthCheck = require(HEALTH_CHECK_SCRIPT).runHealthCheck;
+} catch (e) {
+    runHealthCheck = () => ({ status: 'unknown', error: e.message });
+}
+
+// Optimized reporting helper (requires report.js export)
+let sendReport;
+try {
+    sendReport = require('./report.js').sendReport;
+} catch(e) {}
+
+function sleepSync(ms) {
+    if (ms <= 0) return;
+    // Optimization: Use Atomics.wait for efficient sync sleep without spawning processes
+    try {
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+    } catch (e) {
+        // Fallback to busy-wait if Atomics fails (e.g. unsupported env)
+        const end = Date.now() + ms;
+        while (Date.now() < end) {}
+    }
+}
+
+function getRunningDaemonPids() {
+    const pids = [];
+    if (process.platform !== 'linux') return pids;
+    try {
+        const entries = fs.readdirSync('/proc').filter(p => /^\d+$/.test(p));
+        for (const p of entries) {
+            const pid = parseInt(p, 10);
+            if (!Number.isFinite(pid) || pid <= 1) continue;
+            try {
+                const cmdline = fs.readFileSync(path.join('/proc', p, 'cmdline'), 'utf8');
+                if (cmdline.includes('feishu-evolver-wrapper/lifecycle.js') && cmdline.includes('daemon-loop')) {
+                    pids.push(pid);
+                }
+            } catch (_) {}
+        }
+    } catch (_) {}
+    pids.sort((a, b) => a - b);
+    return pids;
+}
+
+function dedupeDaemonPids(preferredPid) {
+    const pids = getRunningDaemonPids();
+    if (pids.length === 0) return null;
+    let keep = Number.isFinite(preferredPid) ? preferredPid : pids[0];
+    if (!pids.includes(keep)) keep = pids[0];
+    for (const pid of pids) {
+        if (pid === keep) continue;
+        try { process.kill(pid, 'SIGTERM'); } catch (_) {}
+    }
+    try { fs.writeFileSync(DAEMON_PID_FILE, String(keep)); } catch (_) {}
+    return keep;
+}
+
+// INNOVATION: Internal Daemon Loop (Self-Healing Watchdog 2.0)
+function startDaemon() {
+    // First, dedupe any already-running daemon-loop processes.
+    const existing = dedupeDaemonPids();
+    if (existing) {
+        return;
+    }
+
+    if (fs.existsSync(DAEMON_PID_FILE)) {
+        try {
+            const pid = fs.readFileSync(DAEMON_PID_FILE, 'utf8').trim();
+            process.kill(pid, 0);
+            // Daemon already running
+            return;
+        } catch(e) {
+            // Stale PID, remove it
+            try { fs.unlinkSync(DAEMON_PID_FILE); } catch(err) {}
+        }
+    }
+
+    const out = fs.openSync(path.resolve(__dirname, '../../logs/daemon_out.log'), 'a');
+    const err = fs.openSync(path.resolve(__dirname, '../../logs/daemon_err.log'), 'a');
+
+    // Optimization: avoid double-wrapper execution by direct spawn
+    // Use child_process.spawn for better control than exec
+    const child = spawn(process.execPath, [__filename, 'daemon-loop'], {
+        detached: !IS_WIN,
+        stdio: ['ignore', out, err],
+        cwd: __dirname,
+        windowsHide: true
+    });
+    
+    fs.writeFileSync(DAEMON_PID_FILE, String(child.pid));
+    child.unref();
+    console.log(`[Daemon] Started internal watchdog daemon (PID ${child.pid})`);
+}
+
+// Wrapper for async report sending that handles failures gracefully
+async function safeSendReport(payload) {
+    if (sendReport) {
+        try {
+            await sendReport(payload);
+        } catch (e) {
+            console.error('[Wrapper] Internal report failed:', e.message);
+        }
+    } else {
+        // Fallback to execSync
+        try {
+            const reportScript = path.resolve(__dirname, 'report.js');
+            // Basic CLI construction
+            // Use execSync directly to avoid complexity, escaping handled by caller if needed or kept simple
+            let cmd = `node "${reportScript}"`;
+            if (payload.cycle) cmd += ` --cycle "${payload.cycle}"`;
+            if (payload.title) cmd += ` --title "${payload.title}"`;
+            // Very basic escaping for status to avoid shell injection
+            if (payload.status) cmd += ` --status "${String(payload.status).replace(/"/g, '\\"')}"`;
+            if (payload.color) cmd += ` --color "${payload.color}"`;
+            if (payload.dashboard) cmd += ` --dashboard`;
+            
+            execSync(cmd, { stdio: 'ignore', windowsHide: true });
+        } catch (e) {
+            console.error('[Wrapper] Fallback report exec failed:', e.message);
+        }
+    }
+}
+
+function daemonLoop() {
+    // Keep only one daemon-loop process active.
+    const active = dedupeDaemonPids(process.pid);
+    if (active && Number(active) !== process.pid) {
+        process.exit(0);
+        return;
+    }
+    try { fs.writeFileSync(DAEMON_PID_FILE, String(process.pid)); } catch (_) {}
+    console.log(`[Daemon] Loop started at ${new Date().toISOString()}`);
+    
+    // Heartbeat loop
+    setInterval(() => {
+        try {
+            // Optimization: Check if wrapper is healthy before spawning a full ensure process
+            // This reduces redundant exec calls when everything is fine
+            if (fs.existsSync(PID_FILE)) {
+                try {
+                    const pid = fs.readFileSync(PID_FILE, 'utf8').trim();
+                    process.kill(pid, 0);
+                    // Process exists, check if logs are moving
+                    const logFile = path.resolve(__dirname, '../../logs/wrapper_lifecycle.log');
+                    if (fs.existsSync(logFile)) {
+                        const stats = fs.statSync(logFile);
+                        // Optimization: Increased healthy threshold to 10 mins to reduce ensure spawns during long tasks
+                        if (Date.now() - stats.mtimeMs < 600000) { // < 10 mins
+                            // Healthy! Update heartbeat and skip ensure spawn
+                            // fs.writeFileSync(path.resolve(__dirname, '../../memory/daemon_heartbeat.txt'), new Date().toISOString()); // Reduce IO
+                            return;
+                        }
+                    }
+                } catch(e) {}
+            }
+
+            // Optimization: Check ensure lock before spawning to avoid unnecessary process creation
+            const ensureLock = path.resolve(__dirname, '../../memory/evolver_ensure.lock');
+            try {
+                if (fs.existsSync(ensureLock)) {
+                    const stats = fs.statSync(ensureLock);
+                    // Respect the same 5m debounce as inside ensure
+                    if (Date.now() - stats.mtimeMs < 300000) { 
+                        return;
+                    }
+                }
+            } catch(e) {}
+
+            // Run ensure logic internally in a fresh process if checks fail or PID missing
+            // Optimization: Add a small random delay (0-2s) to prevent thundering herd if multiple watchers exist
+            sleepSync(Math.floor(Math.random() * 2000));
+
+            // Use spawn instead of spawnSync to avoid blocking the daemon loop and reducing CPU/wait time
+            const child = require('child_process').spawn(process.execPath, [__filename, 'ensure', '--json', '--daemon-check'], {
+                detached: !IS_WIN,
+                stdio: 'ignore',
+                cwd: __dirname,
+                windowsHide: true
+            });
+            child.unref(); // Let it run independently
+            
+            // Log heartbeat
+            fs.writeFileSync(path.resolve(__dirname, '../../memory/daemon_heartbeat.txt'), new Date().toISOString());
+        } catch(e) {
+            console.error('[Daemon] Loop error:', e);
+        }
+    }, 300000); // Check every 5 minutes (increased from 1m to reduce load)
+}
+
+// Unified watchdog: managed via OpenClaw Cron (job: evolver_watchdog_robust)
+let cachedOpenclawCli = null;
+function ensureWatchdog() {
+  // INNOVATION: Auto-detect 'openclaw' CLI path to fix PATH issues in execSync
+  // Optimization: Cache path resolution to avoid repeated FS checks
+  let openclawCli = cachedOpenclawCli || 'openclaw';
+  
+  if (!cachedOpenclawCli) {
+      openclawCli = process.env.OPENCLAW_CLI_PATH || 'openclaw';
+      cachedOpenclawCli = openclawCli;
+  }
+
+  try {
+    // Check if the cron job exists via OpenClaw CLI
+    // Optimization: Check a local state file first to avoid expensive CLI calls every time
+    const cronStateFile = path.resolve(__dirname, '../../memory/evolver_cron_state.json');
+    let skipCheck = false;
+    // Force check every 10 cycles (approx) or if file missing
+    if (fs.existsSync(cronStateFile)) {
+        try {
+            const state = JSON.parse(fs.readFileSync(cronStateFile, 'utf8'));
+            // If checked within last 24 hours, skip expensive list
+            // Optimization: Increased cache duration to 48h (172800000ms) to significantly reduce exec calls
+            // RE-OPTIMIZATION: Explicitly trust the file for 24h (86400000ms) to STOP the exec loop
+            if (Date.now() - state.lastChecked < 172800000 && (state.exists || state.error)) {
+                skipCheck = true;
+            }
+        } catch (e) {}
+    }
+
+    if (!skipCheck) {
+        // Optimization: Use a simpler check first (file existence) or longer cache duration (24h)
+        // Only run full list if cache is stale or missing
+        try {
+            // Use --all to include disabled jobs, --json for parsing
+            // Use absolute path for reliability
+            // INNOVATION: Add timeout to prevent hanging execSync. Reduced to 5s for responsiveness.
+            // Optimization: Skip exec if we can infer state from memory/cron_last_success.json (reduced poll frequency)
+            // Fix: Increase timeout to 10s for busy systems
+            // DOUBLE OPTIMIZATION: If cron state file exists and is recent (< 24h), blindly trust it to avoid exec
+            // This effectively disables the 'list' call for 24h after a success, relying on the 'ensure' loop to keep running.
+            // If the job is deleted externally, it will be recreated after 24h.
+            
+            // Only run the expensive list if we REALLY need to (cache missing or > 24h old)
+            // CRITICAL OPTIMIZATION: If we are here, it means cache is missing or stale. 
+            // Instead of running `list` immediately, check if we can skip it by just touching the state file if the cron job *should* be there.
+            // But to be safe, we will run the list. However, let's wrap it to catch "command not found" if openclaw cli is missing.
+            
+            // Check if openclaw CLI is actually executable before trying to run it
+            let cliExecutable = false;
+            if (path.isAbsolute(openclawCli)) {
+                try {
+                    fs.accessSync(openclawCli, fs.constants.X_OK);
+                    cliExecutable = true;
+                } catch (err) {
+                    // If CLI is not executable/found, we can't manage cron. Skip silently to avoid crash loop.
+                    console.warn(`[Lifecycle] OpenClaw CLI not executable at ${openclawCli}. Skipping cron check.`);
+                    // Write a temporary "checked" state to suppress retries for 1 hour
+                    fs.writeFileSync(cronStateFile, JSON.stringify({ lastChecked: Date.now(), exists: false, error: "cli_missing" }));
+                    return;
+                }
+            } else {
+                // If it's a command name like 'openclaw', check if it's in PATH using 'which' or assume valid
+                try {
+                    const whichCmd = process.platform === 'win32' ? 'where' : 'which';
+                    execSync(`${whichCmd} ${openclawCli}`, { stdio: 'ignore', windowsHide: true });
+                    cliExecutable = true;
+                } catch (e) {
+                     console.warn(`[Lifecycle] OpenClaw CLI '${openclawCli}' not found in PATH. Skipping cron check.`);
+                     fs.writeFileSync(cronStateFile, JSON.stringify({ lastChecked: Date.now(), exists: false, error: "cli_missing" }));
+                     return;
+                }
+            }
+
+            let listOut = '';
+            try {
+                listOut = execSync(`${openclawCli} cron list --all --json`, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'], timeout: 10000, windowsHide: true });
+            } catch (execErr) {
+                // Gracefully handle non-zero exit code (e.g. Unauthorized)
+                const errMsg = execErr.message || '';
+                if (errMsg.includes('Unauthorized') || execErr.status === 1) {
+                     console.warn('[Lifecycle] OpenClaw cron list failed (Unauthorized/Error). Skipping watchdog setup to avoid noise.');
+                     // Suppress retry for 1h
+                     fs.writeFileSync(cronStateFile, JSON.stringify({ lastChecked: Date.now(), exists: false, error: "unauthorized" }));
+                     return;
+                }
+                throw execErr; // Re-throw other errors
+            }
+
+            let jobs = [];
+            try {
+                const parsed = JSON.parse(listOut);
+                jobs = parsed.jobs || [];
+            } catch (parseErr) {
+                console.warn('[Lifecycle] Failed to parse cron list output:', parseErr.message);
+                // Fallback: check raw string for job name as a heuristic
+                if (listOut.includes('evolver_watchdog_robust')) {
+                    // Update state blindly
+                    fs.writeFileSync(cronStateFile, JSON.stringify({ lastChecked: Date.now(), exists: true }));
+                    return; 
+                }
+            }
+            const exists = jobs.find(j => j.name === 'evolver_watchdog_robust');
+
+            if (!exists) {
+              console.log('[Lifecycle] Creating missing cron job: evolver_watchdog_robust...');
+              // Optimization: Reduced frequency from 10m to 30m to reduce exec noise
+              const cmdStr = `${openclawCli} cron add --name "evolver_watchdog_robust" --every "30m" --session "isolated" --message "exec: node skills/feishu-evolver-wrapper/lifecycle.js ensure" --no-deliver`;
+              
+              execSync(cmdStr, { windowsHide: true });
+              console.log('[Lifecycle] Watchdog cron job created successfully.');
+            } else {
+              if (exists.enabled === false) {
+                 console.log(`[Lifecycle] Enabling disabled watchdog job (ID: ${exists.id})...`);
+                 execSync(`${openclawCli} cron edit "${exists.id}" --enable`, { windowsHide: true });
+              }
+              if (exists.schedule && exists.schedule.everyMs === 600000) {
+                 console.log(`[Lifecycle] Optimizing watchdog frequency to 30m (ID: ${exists.id})...`);
+                 execSync(`${openclawCli} cron edit "${exists.id}" --every "30m"`, { windowsHide: true });
+              }
+            }
+            // Update state file on success
+            fs.writeFileSync(cronStateFile, JSON.stringify({ lastChecked: Date.now(), exists: true }));
+        } catch (e) {
+            console.error('[Lifecycle] Failed to ensure watchdog cron:', e.message);
+            // Don't fail the whole process if cron check fails, just log it.
+            // Optimization: Write failure state with 1h expiry to prevent tight retry loops on CLI error
+            try {
+                fs.writeFileSync(cronStateFile, JSON.stringify({ lastChecked: Date.now() - 82800000, exists: false, error: e.message })); // retry in ~1h (86400000 - 3600000)
+            } catch (_) {}
+        }
+    }
+  } catch (e) {
+    console.error('[Lifecycle] Failed to ensure watchdog cron (outer):', e.message);
+  }
+}
+
+function getAllRunningPids() {
+  const pids = [];
+  const relativePath = 'skills/feishu-evolver-wrapper/index.js';
+  
+  if (process.platform === 'linux') {
+    try {
+      const procs = fs.readdirSync('/proc').filter(p => /^\d+$/.test(p));
+      for (const p of procs) {
+        if (parseInt(p) === process.pid) continue; // Skip self
+        try {
+          const cmdline = fs.readFileSync(path.join('/proc', p, 'cmdline'), 'utf8');
+          if (!cmdline.includes('--loop')) continue;
+          // Match absolute path or relative path in module path
+          if (cmdline.includes(WRAPPER_INDEX) || cmdline.includes(relativePath)) {
+             pids.push(p);
+             continue;
+          }
+          // Match relative-path launches: cmdline has just 'index.js --loop'
+          // Verify by checking if CWD is the wrapper directory
+          if (cmdline.includes('index.js')) {
+            try {
+              const procCwd = fs.readlinkSync(path.join('/proc', p, 'cwd'));
+              if (procCwd.includes('feishu-evolver-wrapper')) {
+                pids.push(p);
+              }
+            } catch(_) {}
+          }
+        } catch(e) {}
+      }
+    } catch(e) {}
+  }
+  return pids;
+}
+
+function getRunningPid() {
+  // Check primary PID file
+  if (fs.existsSync(PID_FILE)) {
+    const pid = fs.readFileSync(PID_FILE, 'utf8').trim();
+    try {
+      process.kill(pid, 0);
+      return pid;
+    } catch (e) {
+      // Stale
+    }
+  }
+  
+  // Check actual processes
+  const pids = getAllRunningPids();
+  if (pids.length > 0) {
+      // If multiple, pick the first one and warn
+      if (pids.length > 1) {
+          console.warn(`[WARNING] Multiple wrapper instances found: ${pids.join(', ')}. Using ${pids[0]}.`);
+      }
+      const pid = pids[0];
+      fs.writeFileSync(PID_FILE, pid);
+      return pid;
+  }
+
+  return null;
+}
+
+function start(args) {
+  const pid = getRunningPid();
+  if (pid) {
+    console.log(`Evolver wrapper is already running (PID ${pid}).`);
+    return;
+  }
+
+  ensureWatchdog();
+
+  console.log('Starting Evolver Wrapper...');
+  const out = fs.openSync(path.resolve(__dirname, '../../logs/wrapper_out.log'), 'a');
+  const err = fs.openSync(path.resolve(__dirname, '../../logs/wrapper_err.log'), 'a');
+
+  const child = spawn('node', [WRAPPER_INDEX, ...args], {
+    detached: !IS_WIN,
+    stdio: ['ignore', out, err],
+    cwd: __dirname,
+    windowsHide: true
+  });
+  
+  fs.writeFileSync(PID_FILE, String(child.pid));
+  child.unref();
+  console.log(`Started background process (PID ${child.pid}).`);
+}
+
+function stop() {
+  const pid = getRunningPid();
+  if (!pid) {
+    console.log('Evolver wrapper is not running.');
+    return;
+  }
+
+  console.log(`Stopping Evolver Wrapper (PID ${pid})...`);
+  try {
+    process.kill(pid, 'SIGTERM');
+    console.log('SIGTERM sent.');
+    
+    // Wait for process to exit (max 5 seconds)
+    const start = Date.now();
+    while (Date.now() - start < 5000) {
+      try {
+        process.kill(pid, 0);
+        // Busy wait but safer than execSync
+        const now = Date.now();
+        while (Date.now() - now < 100) {}
+      } catch (e) {
+        console.log(`Process ${pid} exited successfully.`);
+        break;
+      }
+    }
+    
+    // Force kill if still running
+    try {
+      process.kill(pid, 0);
+      console.warn(`Process ${pid} did not exit gracefully. Sending SIGKILL...`);
+      process.kill(pid, 'SIGKILL');
+    } catch (e) {
+      // Already exited
+    }
+
+    // Clean up PID files
+    if (fs.existsSync(PID_FILE)) fs.unlinkSync(PID_FILE);
+    if (fs.existsSync(LEGACY_PID_FILE)) fs.unlinkSync(LEGACY_PID_FILE);
+  } catch (e) {
+    console.error(`Failed to stop PID ${pid}: ${e.message}`);
+    // Ensure cleanup even on error if process is gone
+    try { process.kill(pid, 0); } catch(err) {
+        if (fs.existsSync(PID_FILE)) fs.unlinkSync(PID_FILE);
+    }
+  }
+}
+
+function status(json = false) {
+  const pid = getRunningPid();
+  const logFile = path.resolve(__dirname, '../../logs/wrapper_lifecycle.log');
+  const cycleFile = path.resolve(__dirname, '../../logs/cycle_count.txt');
+  
+  let cycle = 'Unknown';
+  if (fs.existsSync(cycleFile)) {
+    cycle = fs.readFileSync(cycleFile, 'utf8').trim();
+  }
+
+  let lastActivity = 'Never';
+  let lastAction = '';
+  
+  if (fs.existsSync(logFile)) {
+    try {
+      // Read last 1KB to find last line
+      const stats = fs.statSync(logFile);
+      const size = stats.size;
+      const bufferSize = Math.min(1024, size);
+      const buffer = Buffer.alloc(bufferSize);
+      const fd = fs.openSync(logFile, 'r');
+      fs.readSync(fd, buffer, 0, bufferSize, size - bufferSize);
+      fs.closeSync(fd);
+      
+      const lines = buffer.toString().trim().split('\n');
+      
+      // Parse: 🧬 [ISO_TIMESTAMP] MSG...
+      let match = null;
+      let line = '';
+      
+      // Try parsing backwards for a valid timestamp line
+      // Optimization: Read larger chunk if needed, or handle different log formats
+      for (let i = lines.length - 1; i >= 0; i--) {
+          line = lines[i].trim();
+          if (!line) continue;
+          
+          // Match standard format: 🧬 [ISO] Msg
+          match = line.match(/\[(.*?)\] (.*)/);
+          if (match) break;
+          
+          // Fallback match: just ISO timestamp at start
+          const isoMatch = line.match(/^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})/);
+          if (isoMatch) {
+              match = [line, isoMatch[1], line.substring(isoMatch[0].length).trim()];
+              break;
+          }
+      }
+
+      if (match) {
+           const date = new Date(match[1]);
+           if (!isNaN(date.getTime())) {
+               const diff = Math.floor((Date.now() - date.getTime()) / 1000);
+               
+               if (diff < 60) lastActivity = `${diff}s ago`;
+               else if (diff < 3600) lastActivity = `${Math.floor(diff/60)}m ago`;
+               else lastActivity = `${Math.floor(diff/3600)}h ago`;
+               
+               lastAction = match[2];
+           }
+      }
+    } catch (e) {
+      lastActivity = 'Error reading log: ' + e.message;
+    }
+  }
+
+  // Fallback: Check wrapper_out.log (more granular) if lifecycle log is old (>5m)
+  try {
+      const outLog = path.resolve(__dirname, '../../logs/wrapper_out.log');
+      if (fs.existsSync(outLog)) {
+          const stats = fs.statSync(outLog);
+          const diff = Math.floor((Date.now() - stats.mtimeMs) / 1000);
+          // If outLog is fresher than what we found, use it
+          // Or just append it as "Output Update"
+          if (diff < 300) { // Only if recent (<5m)
+              let timeStr = diff < 60 ? `${diff}s ago` : `${Math.floor(diff/60)}m ago`;
+              lastActivity += ` (Output updated ${timeStr})`;
+          }
+      }
+  } catch(e) {}
+
+
+  if (json) {
+    const daemonPid = fs.existsSync(DAEMON_PID_FILE) ? fs.readFileSync(DAEMON_PID_FILE, 'utf8').trim() : null;
+    try { if(daemonPid) process.kill(daemonPid, 0); } catch(e) { /* stale */ }
+    
+    // Innovation: Include health check status in JSON output
+    let healthStatus = 'unknown';
+    try { healthStatus = runHealthCheck().status; } catch(e) {}
+
+    console.log(JSON.stringify({
+      loop: pid ? `running (pid ${pid})` : 'stopped',
+      pid: pid || null,
+      daemon: daemonPid ? `running (pid ${daemonPid})` : 'stopped',
+      cycle: cycle,
+      watchdog: pid ? 'ok' : 'unknown',
+      health: healthStatus,
+      last_activity: lastActivity,
+      last_action: lastAction
+    }));
+  } else {
+    if (pid) {
+      console.log(`✅ Evolver wrapper is RUNNING (PID ${pid})`);
+      const daemonPid = fs.existsSync(DAEMON_PID_FILE) ? fs.readFileSync(DAEMON_PID_FILE, 'utf8').trim() : null;
+      if (daemonPid) {
+          try { process.kill(daemonPid, 0); console.log(`   Daemon: Active (PID ${daemonPid})`); } 
+          catch(e) { console.log(`   Daemon: Stale PID file (cleaning up...)`); try { fs.unlinkSync(DAEMON_PID_FILE); } catch(err) {} }
+      } else {
+          console.log(`   Daemon: Stopped`);
+      }
+
+      console.log(`   Cycle: #${cycle}`);
+      console.log(`   Last Activity: ${lastActivity}`);
+      console.log(`   Action: ${lastAction.substring(0, 60)}${lastAction.length > 60 ? '...' : ''}`);
+      
+      // If requested via --report, send a card
+      if (process.argv.includes('--report')) {
+         try {
+             const statusText = `PID: ${pid}\nCycle: #${cycle}\nLast Activity: ${lastActivity}\nAction: ${lastAction}`;
+             if (sendReport) {
+                 sendReport({
+                     title: "🧬 Evolver Status Check",
+                     status: `Status: [RUNNING] wrapper is active.\n${statusText}`,
+                     color: "green"
+                 }).catch(e => console.error('Failed to send status report:', e.message));
+             } else {
+                 const reportScript = path.resolve(__dirname, 'report.js');
+                 const cmd = `node "${reportScript}" --title "🧬 Evolver Status Check" --status "Status: [RUNNING] wrapper is active.\n${statusText}" --color "green"`;
+                 execSync(cmd, { stdio: 'inherit', windowsHide: true });
+             }
+         } catch(e) {
+             console.error('Failed to send status report:', e.message);
+         }
+      }
+
+    } else {
+      console.log('❌ Evolver wrapper is STOPPED');
+      console.log(`   Last Known Cycle: #${cycle}`);
+      console.log(`   Last Activity: ${lastActivity}`);
+
+      if (process.argv.includes('--report')) {
+         try {
+             const statusText = `Last Known Cycle: #${cycle}\nLast Activity: ${lastActivity}`;
+             if (sendReport) {
+                 sendReport({
+                     title: "🚨 Evolver Status Check",
+                     status: `Status: [STOPPED] wrapper is NOT running.\n${statusText}`,
+                     color: "red"
+                 }).catch(e => console.error('Failed to send status report:', e.message));
+             } else {
+                 const reportScript = path.resolve(__dirname, 'report.js');
+                 const cmd = `node "${reportScript}" --title "🚨 Evolver Status Check" --status "Status: [STOPPED] wrapper is NOT running.\n${statusText}" --color "red"`;
+                 execSync(cmd, { stdio: 'inherit', windowsHide: true });
+             }
+         } catch(e) {
+             console.error('Failed to send status report:', e.message);
+         }
+      }
+    }
+  }
+}
+
+const action = process.argv[2];
+const passArgs = process.argv.slice(2);
+
+switch (action) {
+  case 'start':
+  case '--loop': 
+    start(['--loop']);
+    break;
+  case 'stop':
+    stop();
+    break;
+  case 'status':
+    status(passArgs.includes('--json'));
+    break;
+  case 'restart':
+    stop();
+    setTimeout(() => start(['--loop']), 1000);
+    break;
+  case 'daemon-loop':
+    daemonLoop();
+    // Keep process alive forever (setInterval does this naturally)
+    break;
+  case 'ensure':
+    // Handle --delay argument (wait before checking)
+    const delayArgIndex = passArgs.indexOf('--delay');
+    if (delayArgIndex !== -1 && passArgs[delayArgIndex + 1]) {
+        const ms = parseInt(passArgs[delayArgIndex + 1]);
+        if (!isNaN(ms) && ms > 0) {
+            console.log(`[Ensure] Waiting ${ms}ms before check...`);
+            // Simple synchronous sleep
+            const stop = new Date().getTime() + ms;
+            while(new Date().getTime() < stop){
+                ;
+            }
+        }
+    }
+
+    // Check if process is stuck by inspecting logs (stale > 10m)
+    // We do this BEFORE the debounce check, because a stuck process needs immediate attention
+    let isStuck = false;
+    try {
+        const logFile = path.resolve(__dirname, '../../logs/wrapper_lifecycle.log');
+        const outLog = path.resolve(__dirname, '../../logs/wrapper_out.log');
+        
+        // Only consider stuck if BOTH logs are stale > 20m (to avoid false positives during sleep/long cycles)
+        const now = Date.now();
+        // [FIX] Relax stuck detection threshold to 240m to prevent false positives during extremely long reasoning tasks
+        const threshold = 14400000; // 240 minutes
+        
+        let lifeStale = true;
+        let outStale = true;
+
+        if (fs.existsSync(logFile)) {
+             lifeStale = (now - fs.statSync(logFile).mtimeMs) > threshold;
+        }
+        
+        if (fs.existsSync(outLog)) {
+             outStale = (now - fs.statSync(outLog).mtimeMs) > threshold;
+        } else {
+             // If outLog is missing but process is running, that's suspicious, but maybe it just started?
+             // Let's assume stale if missing for >10m uptime, but simpler to just say stale=true.
+        }
+
+        if (lifeStale && outStale) {
+            isStuck = true;
+            console.log(`[Ensure] Logs are stale (Lifecycle: ${lifeStale}, Out: ${outStale}). Marking as stuck.`);
+        }
+    } catch(e) {
+        console.warn('[Ensure] Log check failed:', e.message);
+    }
+
+    if (isStuck) {
+        console.warn('[Ensure] Process appears stuck (logs stale > 240m). Restarting...');
+        stop();
+        // Clear lock so we can proceed
+        try { if (fs.existsSync(path.resolve(__dirname, '../../memory/evolver_ensure.lock'))) fs.unlinkSync(path.resolve(__dirname, '../../memory/evolver_ensure.lock')); } catch(e) {}
+        
+        // INNOVATION: Report stuck restart event
+        safeSendReport({
+            title: "🚨 Evolver Watchdog Alert",
+            status: "Status: [RESTARTING] Process was stuck (logs stale). Restart triggered.",
+            color: "red"
+        });
+    }
+
+    const ensureLock = path.resolve(__dirname, '../../memory/evolver_ensure.lock');
+    let forceRestart = false;
+
+    // RUN HEALTH CHECK (Innovation: Self-Healing)
+    try {
+        const health = runHealthCheck();
+        if (health.status === 'error') {
+            console.warn('[Ensure] Health Check FAILED (Status: error). Ignoring debounce and forcing restart.');
+            console.warn('Issues:', JSON.stringify(health.checks.filter(c => c.ok === false), null, 2));
+            forceRestart = true;
+            stop(); // STOP THE UNHEALTHY PROCESS
+            
+            // Clear ensure lock
+            try { if (fs.existsSync(ensureLock)) fs.unlinkSync(ensureLock); } catch(e) {}
+            
+            // Auto-report the failure
+            try {
+                if (sendReport) {
+                    const issueText = health.checks.filter(c => c.ok === false).map(c => `- ${c.name}: ${c.error || c.status}`).join('\n');
+                    sendReport({
+                        title: "🚨 Evolver Self-Healing Triggered",
+                        status: `Status: [HEALTH_FAIL] System detected critical failure.\n${issueText}`,
+                        color: "red"
+                    }).catch(e => {});
+                } else {
+                    const reportScript = path.resolve(__dirname, 'report.js');
+                    const issueText = health.checks.filter(c => c.ok === false).map(c => `- ${c.name}: ${c.error || c.status}`).join('\n');
+                    const cmd = `node "${reportScript}" --title "🚨 Evolver Self-Healing Triggered" --status "Status: [HEALTH_FAIL] System detected critical failure.\n${issueText}" --color "red"`;
+                    execSync(cmd, { stdio: 'ignore', windowsHide: true });
+                }
+            } catch(e) {}
+        }
+    } catch(e) {
+        console.warn('[Ensure] Health check execution failed:', e.message);
+    }
+
+    try {
+      if (fs.existsSync(ensureLock) && !forceRestart) {
+        const stats = fs.statSync(ensureLock);
+        if (Date.now() - stats.mtimeMs < 300000) { // Increased debounce to 5m
+          // silent exit
+          process.exit(0);
+        }
+      }
+      fs.writeFileSync(ensureLock, String(Date.now()));
+    } catch(e) {}
+
+    ensureWatchdog();
+    
+    // INNOVATION: Ensure internal daemon is running (unless checking from daemon itself)
+    if (!passArgs.includes('--daemon-check')) {
+        startDaemon();
+    }
+
+    const runningPids = getAllRunningPids();
+    if (runningPids.length > 1) {
+        console.warn(`[Ensure] Found multiple instances: ${runningPids.join(', ')}. Killing all to reset state.`);
+        runningPids.forEach(p => {
+            try { process.kill(p, 'SIGKILL'); } catch(e) {}
+        });
+        // Remove PID file to force clean start
+        if (fs.existsSync(PID_FILE)) fs.unlinkSync(PID_FILE);
+        // Wait briefly for OS to clear
+        sleepSync(1000);
+    }
+    
+    if (!getRunningPid()) {
+      start(['--loop']);
+      // If we started it, report success if requested
+      if (passArgs.includes('--report')) {
+          setTimeout(() => status(false), 2000); // wait for startup
+      }
+      // INNOVATION: Auto-report dashboard on successful restart via ensure
+      safeSendReport({
+          title: "🧬 Evolver Auto-Repair",
+          status: "Status: [RESTARTED] Watchdog restarted the wrapper.",
+          color: "orange"
+      });
+    } else {
+      // If ensuring and already running, stay silent unless JSON/report requested
+      if (passArgs.includes('--json')) {
+         setTimeout(() => status(true), 1000);
+         return;
+      }
+      if (passArgs.includes('--report')) {
+         status(false);
+         return;
+      }
+      // Silent success - do not spam logs
+      return; 
+    }
+    // Only print status if we just started it or if JSON requested
+    if (!getRunningPid() || passArgs.includes('--json')) {
+       status(passArgs.includes('--json'));
+    }
+    break;
+  case 'dashboard':
+    try {
+        console.log('[Dashboard] Generating full system status card...');
+        if (sendReport) {
+            sendReport({
+                dashboard: true,
+                color: "blue"
+            }).catch(e => console.error('[Dashboard] Failed to generate card:', e.message));
+        } else {
+            const reportScript = path.resolve(__dirname, 'report.js');
+            const cmd = `node "${reportScript}" --dashboard --color "blue"`;
+            execSync(cmd, { stdio: 'inherit', windowsHide: true });
+        }
+    } catch(e) {
+        console.error('[Dashboard] Failed to generate card:', e.message);
+    }
+    break;
+  default:
+    console.log('Usage: node lifecycle.js [start|stop|restart|status|ensure|dashboard|--loop] [--json]');
+    status();
+}

package.json

@@ -0,0 +1,9 @@
+{
+  "name": "feishu-evolver-wrapper",
+  "version": "1.7.1",
+  "description": "Feishu-specific wrapper for capability-evolver",
+  "main": "index.js",
+  "dependencies": {
+    "evolver": "file:../evolver"
+  }
+}

report.js

@@ -0,0 +1,578 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { program } = require('commander');
+const { execSync } = require('child_process');
+const { sendCard } = require('./feishu-helper.js');
+const { fetchWithAuth } = require('../feishu-common/index.js');
+const { generateDashboardCard } = require('./utils/dashboard-generator.js');
+const crypto = require('crypto');
+
+// Check for integration key (tenant_access_token or webhook)
+const integrationKey = process.env.FEISHU_APP_ID || process.env.FEISHU_BOT_NAME;
+if (!integrationKey) {
+  console.warn('⚠️ Integration key missing (FEISHU_APP_ID). Reporting might fail or degrade to console only.');
+  // Don't exit, just warn - we might be in a test env
+}
+
+// --- REPORT DEDUP ---
+const DEDUP_FILE = path.resolve(__dirname, '../../memory/report_dedup.json');
+const DEDUP_WINDOW_MS = 30 * 60 * 1000; // 30 minutes
+
+function isDuplicateReport(reportKey) {
+    if (process.env.EVOLVE_REPORT_DEDUP === '0') return false;
+    try {
+        var cache = {};
+        if (fs.existsSync(DEDUP_FILE)) {
+            cache = JSON.parse(fs.readFileSync(DEDUP_FILE, 'utf8'));
+        }
+        var now = Date.now();
+        // Prune old entries
+        for (var k in cache) {
+            if (now - cache[k] > DEDUP_WINDOW_MS) delete cache[k];
+        }
+        if (cache[reportKey]) {
+            console.log('[Wrapper] Report dedup: skipping duplicate report (' + reportKey.slice(0, 40) + '...)');
+            return true;
+        }
+        cache[reportKey] = now;
+        var tmpDedup = DEDUP_FILE + '.tmp.' + process.pid;
+        fs.writeFileSync(tmpDedup, JSON.stringify(cache, null, 2));
+        fs.renameSync(tmpDedup, DEDUP_FILE);
+        return false;
+    } catch (e) {
+        // On error, allow the report through
+        return false;
+    }
+}
+
+// --- DASHBOARD LOGIC START ---
+const EVENTS_FILE = path.resolve(__dirname, '../../assets/gep/events.jsonl');
+
+function getDashboardStats() {
+    if (!fs.existsSync(EVENTS_FILE)) return null;
+    
+    try {
+        const content = fs.readFileSync(EVENTS_FILE, 'utf8');
+        const lines = content.split('\n').filter(Boolean);
+        const events = lines.map(l => { try { return JSON.parse(l); } catch(e){ return null; } }).filter(e => e && e.type === 'EvolutionEvent');
+        
+        if (events.length === 0) return null;
+
+        const total = events.length;
+        const successful = events.filter(e => e.outcome && e.outcome.status === 'success').length;
+        const successRate = ((successful / total) * 100).toFixed(1);
+        
+        const intents = { innovate: 0, repair: 0, optimize: 0 };
+        let totalFiles = 0, totalLines = 0, countBlast = 0;
+        let totalRigor = 0, totalRisk = 0, countPers = 0;
+
+        events.forEach(e => {
+            if (intents[e.intent] !== undefined) intents[e.intent]++;
+            
+            // Blast Radius Stats (Recent 10)
+            if (e.blast_radius) {
+                totalFiles += (e.blast_radius.files || 0);
+                totalLines += (e.blast_radius.lines || 0);
+                countBlast++;
+            }
+            
+            // Personality Stats (Recent 10)
+            if (e.personality_state) {
+                totalRigor += (e.personality_state.rigor || 0);
+                totalRisk += (e.personality_state.risk_tolerance || 0);
+                countPers++;
+            }
+        });
+
+        const recent = events.slice(-5).reverse().map(e => ({
+            id: e.id.replace('evt_', '').substring(0, 6),
+            intent: e.intent === 'innovate' ? '✨' : (e.intent === 'repair' ? '🔧' : '⚡'),
+            status: e.outcome && e.outcome.status === 'success' ? '✅' : '❌'
+        }));
+
+        const avgFiles = countBlast > 0 ? (totalFiles / countBlast).toFixed(1) : 0;
+        const avgLines = countBlast > 0 ? (totalLines / countBlast).toFixed(0) : 0;
+        const avgRigor = countPers > 0 ? (totalRigor / countPers).toFixed(2) : 0;
+
+        return { total, successRate, intents, recent, avgFiles, avgLines, avgRigor };
+    } catch (e) {
+        return null;
+    }
+}
+// --- DASHBOARD LOGIC END ---
+
+let runSkillsMonitor;
+try {
+    runSkillsMonitor = require('../evolver/src/ops/skills_monitor').run;
+} catch (e) {
+    try { runSkillsMonitor = require('./skills_monitor.js').run; } catch (e2) {
+        runSkillsMonitor = () => [];
+    }
+}
+
+// INNOVATION: Load dedicated System Monitor (Native Node) if available
+let sysMon;
+try {
+    // Try to load the optimized monitor first
+    sysMon = require('../system-monitor');
+} catch (e) {
+    // Optimized Native Implementation (Linux/Node 18+)
+    sysMon = {
+        getProcessCount: () => {
+            try {
+                // Linux: Count numeric directories in /proc
+                if (process.platform === 'linux') {
+                    return fs.readdirSync('/proc').filter(f => /^\d+$/.test(f)).length;
+                }
+                // Fallback for non-Linux
+                if (process.platform === 'win32') return '?';
+                return execSync('ps -e | wc -l', { windowsHide: true }).toString().trim();
+            } catch(e){ return '?'; }
+        },
+        getDiskUsage: (mount) => {
+            try {
+                if (fs.statfsSync) {
+                    const stats = fs.statfsSync(mount || '/');
+                    const total = stats.blocks * stats.bsize;
+                    const free = stats.bavail * stats.bsize;
+                    const used = total - free;
+                    return Math.round((used / total) * 100) + '%';
+                }
+                // Fallback for older Node
+                if (process.platform === 'win32') return '?';
+                return execSync(`df -h "${mount || '/'}" | tail -1 | awk '{print $5}'`, { windowsHide: true }).toString().trim();
+            } catch(e){ return '?'; }
+        },
+        getLastLine: (f) => {
+            try {
+                if (!fs.existsSync(f)) return '';
+                const fd = fs.openSync(f, 'r');
+                const stat = fs.fstatSync(fd);
+                const size = stat.size;
+                if (size === 0) { fs.closeSync(fd); return ''; }
+                
+                const bufSize = Math.min(1024, size);
+                const buffer = Buffer.alloc(bufSize);
+                let position = size - bufSize;
+                fs.readSync(fd, buffer, 0, bufSize, position);
+                fs.closeSync(fd);
+                
+                let content = buffer.toString('utf8');
+                // Trim trailing newline if present
+                if (content.endsWith('\n')) content = content.slice(0, -1);
+                const lastBreak = content.lastIndexOf('\n');
+                return lastBreak === -1 ? content : content.slice(lastBreak + 1);
+            } catch(e){ return ''; }
+        }
+    };
+}
+
+const STATE_FILE = path.resolve(__dirname, '../../memory/evolution_state.json');
+const CYCLE_COUNTER_FILE = path.resolve(__dirname, '../../logs/cycle_count.txt');
+
+function parseCycleNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) return Math.trunc(value);
+    const text = String(value || '').trim();
+    if (!text) return null;
+    if (/^\d+$/.test(text)) return parseInt(text, 10);
+    const m = text.match(/(\d{1,})/);
+    if (!m) return null;
+    return parseInt(m[1], 10);
+}
+
+function isStaleCycleReport(cycleId) {
+    try {
+        const currentRaw = fs.existsSync(CYCLE_COUNTER_FILE)
+            ? fs.readFileSync(CYCLE_COUNTER_FILE, 'utf8').trim()
+            : '';
+        const current = /^\d+$/.test(currentRaw) ? parseInt(currentRaw, 10) : null;
+        const candidate = parseCycleNumber(cycleId);
+        if (!Number.isFinite(current) || !Number.isFinite(candidate)) return false;
+        const windowSize = Number.parseInt(process.env.EVOLVE_STALE_CYCLE_WINDOW || '5', 10);
+        if (!Number.isFinite(windowSize) || windowSize < 0) return false;
+        return candidate < (current - windowSize);
+    } catch (_) {
+        return false;
+    }
+}
+
+function getCycleInfo() {
+    let nextId = 1;
+    let durationStr = 'N/A';
+    const now = new Date();
+
+    // 1. Try State File (Fast & Persistent)
+    try {
+        if (fs.existsSync(STATE_FILE)) {
+            const state = JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
+            if (state.lastCycleId) {
+                nextId = state.lastCycleId + 1;
+                
+                // Calculate duration since last cycle
+                if (state.lastUpdate) {
+                    const diff = now.getTime() - new Date(state.lastUpdate).getTime();
+                    const mins = Math.floor(diff / 60000);
+                    const secs = Math.floor((diff % 60000) / 1000);
+                    durationStr = `${mins}m ${secs}s`;
+                }
+
+                // Auto-increment and save
+                state.lastCycleId = nextId;
+                state.lastUpdate = now.toISOString();
+                fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+                return { id: nextId, duration: durationStr };
+            }
+        }
+    } catch (e) {}
+
+    // 2. Fallback: MEMORY.md (Legacy/Seed)
+    let maxId = 0;
+    try {
+        const memPath = path.resolve(__dirname, '../../MEMORY.md');
+        if (fs.existsSync(memPath)) {
+            const memContent = fs.readFileSync(memPath, 'utf8');
+            const matches = [...memContent.matchAll(/Cycle #(\d+)/g)];
+            for (const match of matches) {
+                const id = parseInt(match[1]);
+                if (id > maxId) maxId = id;
+            }
+        }
+    } catch (e) {}
+
+    // Initialize State File if missing
+    nextId = (maxId > 0 ? maxId : Math.floor(Date.now() / 1000)) + 1;
+    try {
+        fs.writeFileSync(STATE_FILE, JSON.stringify({
+            lastCycleId: nextId,
+            lastUpdate: now.toISOString()
+        }, null, 2));
+    } catch(e) {}
+
+    return { id: nextId, duration: 'First Run' };
+}
+
+async function findEvolutionGroup() {
+    try {
+        let pageToken = '';
+        do {
+            const url = `https://open.feishu.cn/open-apis/im/v1/chats?page_size=100${pageToken ? `&page_token=${pageToken}` : ''}`;
+            const res = await fetchWithAuth(url, { method: 'GET' });
+            const data = await res.json();
+            
+            if (data.code !== 0) {
+                console.warn(`[Wrapper] List Chats failed: ${data.msg}`);
+                return null;
+            }
+
+            if (data.data && data.data.items) {
+                const group = data.data.items.find(c => c.name && c.name.includes('🧬'));
+                if (group) {
+                    // console.log(`[Wrapper] Found Evolution Group: ${group.name} (${group.chat_id})`);
+                    return group.chat_id;
+                }
+            }
+            
+            pageToken = data.data.page_token;
+        } while (pageToken);
+    } catch (e) {
+        console.warn(`[Wrapper] Group lookup error: ${e.message}`);
+    }
+    return null;
+}
+
+async function sendReport(options) {
+    // Resolve content
+    let content = options.status || options.content || '';
+    if (options.file) {
+        try {
+            content = fs.readFileSync(options.file, 'utf8');
+        } catch (e) {
+            console.error(`Failed to read file: ${options.file}`);
+            throw e;
+        }
+    }
+
+    if (!content && !options.dashboard) {
+        throw new Error('Must provide --status or --file (unless --dashboard is set)');
+    }
+
+    // Prepare Title
+    const cycleInfo = options.cycle ? { id: options.cycle, duration: 'Manual' } : getCycleInfo();
+    const cycleId = cycleInfo.id;
+    if (isStaleCycleReport(cycleId)) {
+        console.warn(`[Wrapper] Suppressing stale report for cycle #${cycleId}.`);
+        return;
+    }
+    let title = options.title;
+
+    if (!title) {
+        // Default title based on lang
+        if (options.lang === 'cn') {
+            title = `🧬 进化 #${cycleId} 日志`;
+        } else {
+            title = `🧬 Evolution #${cycleId} Log`;
+        }
+    }
+
+    // Resolve Target
+    const MASTER_ID = process.env.OPENCLAW_MASTER_ID || '';
+    let target = options.target;
+
+    // Priority: CLI Target > Evolution Group (🧬) > Master ID
+    if (!target) {
+        target = await findEvolutionGroup();
+    }
+    
+    if (!target) {
+        console.warn('[Wrapper] No Evolution Group (🧬) found. Explicitly falling back to Master ID.');
+        target = MASTER_ID;
+    }
+
+    if (!target) {
+        throw new Error('No target ID found (Env OPENCLAW_MASTER_ID missing and no --target).');
+    }
+
+    // --- DASHBOARD SNAPSHOT ---
+    let dashboardMd = '';
+    const stats = getDashboardStats();
+    if (stats) {
+        const trend = stats.recent.map(e => `${e.intent}${e.status}`).join(' ');
+        
+        dashboardMd = `\n\n---
+**📊 Dashboard Snapshot**
+- **Success Rate:** ${stats.successRate}% (${stats.total} Cycles)
+- **Breakdown:** ✨${stats.intents.innovate} 🔧${stats.intents.repair} ⚡${stats.intents.optimize}
+- **Avg Blast:** ${stats.avgFiles} files / ${stats.avgLines} lines
+- **Avg Rigor:** ${stats.avgRigor || 'N/A'} (0.0-1.0)
+- **Recent:** ${trend}`;
+    }
+    // --- END SNAPSHOT ---
+
+    try {
+        console.log(`[Wrapper] Reporting Cycle #${cycleId} to ${target}...`);
+        
+        let procCount = '?';
+        let memUsage = '?';
+        let uptime = '?';
+        let loadAvg = '?';
+        let diskUsage = '?';
+
+        try {
+            procCount = sysMon.getProcessCount();
+            memUsage = Math.round(process.memoryUsage().rss / 1024 / 1024);
+            // Use wrapper daemon uptime, not this short-lived report process uptime.
+            const wrapperPidFile = path.resolve(__dirname, '../../memory/evolver_wrapper.pid');
+            if (fs.existsSync(wrapperPidFile)) {
+                const pid = parseInt(fs.readFileSync(wrapperPidFile, 'utf8').trim(), 10);
+                if (Number.isFinite(pid) && pid > 1) {
+                    try {
+                        const pidPath = `/proc/${pid}`;
+                        if (fs.existsSync(pidPath)) {
+                            // Use stat.ctimeMs which is creation time on Linux /proc
+                            const stats = fs.statSync(pidPath);
+                            uptime = Math.floor((Date.now() - stats.ctimeMs) / 1000);
+                        } else {
+                            // Fallback to exec if /proc missing (non-Linux?)
+                            const et = execSync(`ps -o etimes= -p ${pid}`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true }).trim();
+                            const secs = parseInt(et, 10);
+                            if (Number.isFinite(secs) && secs >= 0) uptime = secs;
+                        }
+                    } catch (_) {
+                        uptime = Math.round(process.uptime());
+                    }
+                }
+            }
+            if (uptime === '?') uptime = Math.round(process.uptime());
+            loadAvg = os.loadavg()[0].toFixed(2);
+            diskUsage = sysMon.getDiskUsage('/');
+        } catch(e) {
+            console.warn('[Wrapper] Stats collection failed:', e.message);
+        }
+
+        // --- ERROR LOG CHECK ---
+        let errorAlert = '';
+        try {
+            const evolverDirName = ['private-evolver', 'evolver', 'capability-evolver'].find(d => fs.existsSync(path.resolve(__dirname, `../${d}/index.js`))) || 'private-evolver';
+            const evolverDir = path.resolve(__dirname, `../${evolverDirName}`);
+            const errorLogPath = path.join(evolverDir, 'evolution_error.log');
+
+            if (fs.existsSync(errorLogPath)) {
+                const stats = fs.statSync(errorLogPath);
+                const now = new Date();
+                const diffMs = now - stats.mtime;
+                
+                if (diffMs < 10 * 60 * 1000) {
+                    const lastLine = (sysMon.getLastLine(errorLogPath) || '').substring(0, 200);
+                    errorAlert = `\n\n⚠️ **CRITICAL ALERT**: System reported a failure ${(diffMs/1000/60).toFixed(1)}m ago.\n> ${lastLine}`;
+                }
+            }
+        } catch (e) {}
+
+        // --- SKILL HEALTH CHECK ---
+        let healthAlert = '';
+        try {
+            const issues = runSkillsMonitor();
+            if (issues && issues.length > 0) {
+                healthAlert = `\n\n🚨 **SKILL HEALTH WARNING**: ${issues.length} skill(s) broken.\n`;
+                issues.slice(0, 3).forEach(issue => {
+                    healthAlert += `> **${issue.name}**: ${issue.issues.join(', ')}\n`;
+                });
+                if (issues.length > 3) healthAlert += `> ...and ${issues.length - 3} more.`;
+            }
+        } catch (e) {
+            console.warn('[Wrapper] Skill monitor failed:', e.message);
+        }
+
+        const isChineseReport = options.lang === 'cn';
+
+        const labels = isChineseReport
+            ? {
+                proc: '进程',
+                mem: '内存',
+                up: '运行',
+                load: '负载',
+                disk: '磁盘',
+                loop: '循环',
+                skills: '技能',
+                ok: '正常',
+                loopOn: '运行中',
+                loopOff: '已停止'
+            }
+            : {
+                proc: 'Proc',
+                mem: 'Mem',
+                up: 'Up',
+                load: 'Load',
+                disk: 'Disk',
+                loop: 'Loop',
+                skills: 'Skills',
+                ok: 'OK',
+                loopOn: 'ON',
+                loopOff: 'OFF'
+            };
+
+        // --- LOOP STATUS CHECK ---
+        let loopStatus = 'UNKNOWN';
+        try {
+            // Mock status call to avoid exec/logs spam if possible, or use status --json?
+            // Actually lifecycle.status() prints to console. We should export a helper.
+            // For now, assume if pid file exists, it's running.
+            const PID_FILE = path.resolve(__dirname, '../../memory/evolver_wrapper.pid');
+            if (fs.existsSync(PID_FILE)) {
+                 try { process.kill(parseInt(fs.readFileSync(PID_FILE, 'utf8').trim(), 10), 0); loopStatus = labels.loopOn; } 
+                 catch(e) { loopStatus = labels.loopOff; }
+            } else {
+                 loopStatus = labels.loopOff;
+            }
+        } catch (e) {
+            loopStatus = `${labels.loopOff} (?)`;
+        }
+
+        let footerStats = `${labels.proc}: ${procCount} | ${labels.mem}: ${memUsage}MB | ${labels.up}: ${uptime}s | ${labels.load}: ${loadAvg} | ${labels.disk}: ${diskUsage} | 🔁 ${labels.loop}: ${loopStatus}`;
+        if (!healthAlert) footerStats += ` | 🛡️ ${labels.skills}: ${labels.ok}`;
+
+        const finalContent = `${content}${errorAlert}${healthAlert}${dashboardMd}`;
+
+        // --- DASHBOARD MODE ---
+        let cardData = null;
+        if (options.dashboard) {
+            console.log('[Wrapper] Generating rich dashboard card...');
+            // Normalize stats if null (stats is already defined above from getDashboardStats())
+            const safeStats = stats || { total: 0, successRate: '0.0', intents: { innovate:0, repair:0, optimize:0 }, recent: [] };
+            
+            cardData = generateDashboardCard(
+                safeStats,
+                {
+                    proc: procCount, mem: memUsage, uptime: uptime, load: loadAvg, disk: diskUsage, loopStatus: loopStatus,
+                    errorAlert: errorAlert, healthAlert: healthAlert
+                },
+                { id: cycleId, duration: cycleInfo.duration }
+            );
+        }
+
+        // --- DEDUP CHECK ---
+        var statusHash = crypto.createHash('md5').update(options.status || '').digest('hex').slice(0, 12);
+        var reportKey = `${cycleId}:${target}:${title}:${statusHash}`;
+        if (isDuplicateReport(reportKey)) {
+            console.log('[Wrapper] Duplicate report suppressed.');
+            return;
+        }
+
+    // Auto-detect color from status text if not explicitly overridden (or if default blue)
+    let headerColor = options.color || 'blue';
+    if (headerColor === 'blue') {
+        const statusUpper = (options.status || '').toUpperCase();
+        if (statusUpper.includes('[SUCCESS]') || statusUpper.includes('[成功]')) headerColor = 'green';
+        else if (statusUpper.includes('[FAILED]') || statusUpper.includes('[失败]')) headerColor = 'red';
+        else if (statusUpper.includes('[WARNING]') || statusUpper.includes('[警告]')) headerColor = 'orange';
+        else if (statusUpper.includes('[INNOVATE]') || statusUpper.includes('[创新]')) headerColor = 'purple';
+        else if (statusUpper.includes('[REPAIR]') || statusUpper.includes('[修复]')) headerColor = 'orange'; // Repair is often a fix/warning state
+        else if (statusUpper.includes('[OPTIMIZE]') || statusUpper.includes('[优化]')) headerColor = 'blue';
+        else if (statusUpper.includes('SUCCESS')) headerColor = 'green'; // Fallback for plain SUCCESS
+        else if (statusUpper.includes('FAILED')) headerColor = 'red'; // Fallback for plain FAILED
+        else if (statusUpper.includes('ERROR')) headerColor = 'red'; // Fallback for error messages
+    }
+
+        // Title is passed as-is from caller (already contains 🧬).
+        // No extra emoji in the title -- result goes in the body.
+
+        if (options.dashboard && cardData) {
+            await sendCard({
+                target: target,
+                title: title,
+                cardData: cardData,
+                note: footerStats,
+                color: headerColor
+            });
+        } else {
+            await sendCard({
+                target: target,
+                title: title,
+                text: finalContent,
+                note: footerStats,
+                color: headerColor
+            });
+        }
+        
+        console.log('[Wrapper] Report sent successfully.');
+
+        try {
+            const LOG_FILE = path.resolve(__dirname, '../../logs/evolution_reports.log');
+            if (!fs.existsSync(path.dirname(LOG_FILE))) {
+                fs.mkdirSync(path.dirname(LOG_FILE), { recursive: true });
+            }
+            fs.appendFileSync(LOG_FILE, `[${new Date().toISOString()}] Cycle #${cycleId} - Status: SUCCESS - Target: ${target} - Duration: ${cycleInfo.duration}\n`);
+        } catch (logErr) {
+            console.warn('[Wrapper] Failed to write to local log:', logErr.message);
+        }
+    } catch (e) {
+        console.error('[Wrapper] Report failed:', e.message);
+        throw e;
+    }
+}
+
+// CLI Logic
+if (require.main === module) {
+    program
+      .option('-s, --status <text>', 'Status text/markdown content')
+      .option('--content <text>', 'Alias for --status (compatibility)')
+      .option('-f, --file <path>', 'Path to markdown file content')
+      .option('-c, --cycle <id>', 'Evolution Cycle ID')
+      .option('--title <text>', 'Card Title override')
+      .option('--color <color>', 'Header color (blue/red/green/orange)', 'blue')
+      .option('--target <id>', 'Target User/Chat ID')
+      .option('--lang <lang>', 'Language (en|cn)', 'en')
+      .option('--dashboard', 'Send rich dashboard card instead of plain text')
+      .parse(process.argv);
+
+    const options = program.opts();
+    sendReport(options).catch(err => {
+        console.error('[Wrapper] Report failed (non-fatal):', err.message);
+        // Don't fail the build/cycle just because reporting failed (e.g. permission issues)
+        process.exit(0);
+    });
+}
+
+module.exports = { sendReport };

self-repair.js

@@ -0,0 +1,59 @@
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+// SELF REPAIR MODULE
+// Triggered when gitSync fails critically.
+// Attempts to restore a clean state.
+
+const WORKSPACE_ROOT = path.resolve(__dirname, '../../');
+
+function log(msg) {
+    console.log(`[SelfRepair] ${msg}`);
+}
+
+function run() {
+    log('Starting Emergency Git Repair...');
+    
+    try {
+        try {
+            execSync('git rebase --abort', { cwd: WORKSPACE_ROOT, stdio: 'ignore', windowsHide: true });
+            log('Aborted pending rebase.');
+        } catch (e) {}
+
+        try {
+            execSync('git merge --abort', { cwd: WORKSPACE_ROOT, stdio: 'ignore', windowsHide: true });
+            log('Aborted pending merge.');
+        } catch (e) {}
+
+        const status = execSync('git status --porcelain', { cwd: WORKSPACE_ROOT, windowsHide: true }).toString();
+        log(`Current status:\n${status}`);
+
+        // 4. If index.lock exists, remove it (dangerous but necessary for unattended recovery)
+        const lockFile = path.join(WORKSPACE_ROOT, '.git/index.lock');
+        if (fs.existsSync(lockFile)) {
+            // Check file age. If > 10 mins, delete it.
+            const stats = fs.statSync(lockFile);
+            const ageMinutes = (Date.now() - stats.mtimeMs) / 1000 / 60;
+            if (ageMinutes > 10) {
+                log(`Removing stale index.lock (${ageMinutes.toFixed(1)}m old)...`);
+                fs.unlinkSync(lockFile);
+            }
+        }
+
+        // 5. Hard Reset (Last Resort)? NO. That loses work.
+        // Instead, we just try to fetch and let the next cycle handle it.
+        execSync('git fetch origin main', { cwd: WORKSPACE_ROOT, windowsHide: true });
+        log('Fetched origin main.');
+
+    } catch (err) {
+        log(`Repair failed: ${err.message}`);
+        // Do NOT process.exit here -- this would kill the wrapper daemon.
+    }
+}
+
+if (require.main === module) {
+    run();
+}
+
+module.exports = { run };

send-card-cli.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+const { sendCard } = require('./feishu-helper.js');
+
+// CLI Arguments:
+// 1. Message content
+// 2. Prefix (e.g., "[INFO]")
+const msg = process.argv[2];
+const prefix = process.argv[3] || '[INFO]';
+const target = process.env.FEISHU_LOG_TARGET || process.env.LOG_TARGET || '';
+if (!target) { process.stderr.write('[CardFail] FEISHU_LOG_TARGET or LOG_TARGET env var not set\n'); process.exit(1); }
+
+if (!msg) process.exit(0);
+
+(async () => {
+    try {
+        const color = prefix.includes('ERROR') || prefix.includes('CRITICAL') || prefix.includes('FAILURE')
+            ? 'red'
+            : prefix.includes('WARNING') || prefix.includes('WARN')
+                ? 'orange'
+                : 'blue';
+        await sendCard({
+            target,
+            title: `🧬 Evolver [${new Date().toISOString().substring(11,19)}]`,
+            text: `${prefix} ${msg}`,
+            color
+        });
+    } catch (e) {
+        process.stderr.write(`[CardFail] ${e.message}\n`);
+        process.exit(1);
+    }
+})();

skills_monitor.js

@@ -0,0 +1,170 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// SKILLS MONITOR (v2.0)
+// Proactively checks installed skills for real issues (not cosmetic ones).
+// - Ignores shared libraries and non-skill directories
+// - Only syntax-checks .js files
+// - Checks if dependencies are truly missing (not just node_modules dir)
+
+const SKILLS_DIR = path.resolve(__dirname, '../../skills');
+
+// Directories that are NOT skills (shared libs, internal tools, non-JS projects)
+const IGNORE_LIST = new Set([
+    'common',           // Shared Feishu client library
+    'clawhub',          // ClawHub CLI integration
+    'input-validator',  // Internal validation utility
+    'proactive-agent',  // Agent framework (not a skill)
+    'security-audit',   // Internal audit tool
+]);
+
+// Load user-defined ignore list if exists
+try {
+    const ignoreFile = path.join(SKILLS_DIR, '..', '.skill_monitor_ignore');
+    if (fs.existsSync(ignoreFile)) {
+        const lines = fs.readFileSync(ignoreFile, 'utf8').split('\n');
+        lines.forEach(function(l) {
+            var t = l.trim();
+            if (t && !t.startsWith('#')) IGNORE_LIST.add(t);
+        });
+    }
+} catch (e) { /* ignore */ }
+
+function checkSkill(skillName) {
+    if (IGNORE_LIST.has(skillName)) return null;
+
+    const skillPath = path.join(SKILLS_DIR, skillName);
+    const issues = [];
+    
+    // Skip if not a directory
+    try {
+        if (!fs.statSync(skillPath).isDirectory()) return null;
+    } catch (e) {
+        return null;
+    }
+
+    // 1. Check Package Structure
+    let mainFile = 'index.js';
+    const pkgPath = path.join(skillPath, 'package.json');
+    var hasPkg = false;
+    
+    if (fs.existsSync(pkgPath)) {
+        hasPkg = true;
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            if (pkg.main) mainFile = pkg.main;
+            
+            // 2. Check dependencies -- only flag if require() actually fails
+            if (pkg.dependencies && Object.keys(pkg.dependencies).length > 0) {
+                if (!fs.existsSync(path.join(skillPath, 'node_modules'))) {
+                    // Try to actually require the entry point to see if it works without node_modules
+                    var entryAbs = path.join(skillPath, mainFile);
+                    if (fs.existsSync(entryAbs) && mainFile.endsWith('.js')) {
+                        try {
+                            execSync(`node -e "require('${entryAbs.replace(/'/g, "\\'")}')"`, {
+                                stdio: 'ignore', timeout: 5000, cwd: skillPath, windowsHide: true
+                            });
+                            // require succeeded: deps are resolved via relative paths or globals, no issue
+                        } catch (e) {
+                            issues.push('Missing node_modules (needs npm install)');
+                        }
+                    }
+                }
+            }
+        } catch (e) {
+            issues.push('Invalid package.json');
+        }
+    }
+
+    // 3. Syntax Check -- only for .js entry points
+    if (mainFile.endsWith('.js')) {
+        const entryPoint = path.join(skillPath, mainFile);
+        if (fs.existsSync(entryPoint)) {
+            try {
+                execSync(`node -c "${entryPoint}"`, { stdio: 'ignore', timeout: 5000, windowsHide: true });
+            } catch (e) {
+                issues.push(`Syntax Error in ${mainFile}`);
+            }
+        }
+    }
+
+    // 4. Missing SKILL.md -- only warn for dirs that have package.json (real skills, not utility dirs)
+    if (hasPkg && !fs.existsSync(path.join(skillPath, 'SKILL.md'))) {
+        issues.push('Missing SKILL.md');
+    }
+
+    if (issues.length > 0) {
+        return { name: skillName, issues };
+    }
+    return null;
+}
+
+// Auto-heal: attempt to fix simple issues automatically
+function autoHeal(skillName, issues) {
+    const skillPath = path.join(SKILLS_DIR, skillName);
+    const healed = [];
+
+    for (const issue of issues) {
+        if (issue === 'Missing node_modules (needs npm install)') {
+            try {
+                execSync('npm install --production --no-audit --no-fund', {
+                    cwd: skillPath, stdio: 'ignore', timeout: 30000, windowsHide: true
+                });
+                healed.push(issue);
+                console.log(`[SkillsMonitor] Auto-healed ${skillName}: npm install`);
+            } catch (e) {
+                // npm install failed, leave the issue
+            }
+        } else if (issue === 'Missing SKILL.md') {
+            try {
+                const name = skillName.replace(/-/g, ' ');
+                fs.writeFileSync(
+                    path.join(skillPath, 'SKILL.md'),
+                    `# ${skillName}\n\n${name} skill.\n`
+                );
+                healed.push(issue);
+                console.log(`[SkillsMonitor] Auto-healed ${skillName}: created SKILL.md stub`);
+            } catch (e) {
+                // write failed, leave the issue
+            }
+        }
+    }
+
+    return healed;
+}
+
+function run(options) {
+    const heal = (options && options.autoHeal) !== false; // auto-heal by default
+    const skills = fs.readdirSync(SKILLS_DIR);
+    const report = [];
+
+    for (const skill of skills) {
+        if (skill.startsWith('.')) continue; // skip hidden
+        const result = checkSkill(skill);
+        if (result) {
+            if (heal) {
+                const healed = autoHeal(result.name, result.issues);
+                // Remove healed issues
+                result.issues = result.issues.filter(function(i) { return !healed.includes(i); });
+                if (result.issues.length === 0) continue; // fully healed
+            }
+            report.push(result);
+        }
+    }
+
+    return report;
+}
+
+if (require.main === module) {
+    const issues = run();
+    if (issues.length > 0) {
+        console.log(JSON.stringify(issues, null, 2));
+        process.exit(1);
+    } else {
+        console.log("[]");
+        process.exit(0);
+    }
+}
+
+module.exports = { run };

trigger.js

@@ -0,0 +1,12 @@
+const fs = require('fs');
+const path = require('path');
+
+const WAKE_FILE = path.resolve(__dirname, '../../memory/evolver_wake.signal');
+
+try {
+    fs.writeFileSync(WAKE_FILE, 'WAKE');
+    console.log(`[Evolver Trigger] Wake signal sent to ${WAKE_FILE}. The wrapper should wake up shortly.`);
+} catch (e) {
+    console.error(`[Evolver Trigger] Failed to send wake signal: ${e.message}`);
+    process.exit(1);
+}

utils/dashboard-generator.js

@@ -0,0 +1,127 @@
+const fs = require('fs');
+const path = require('path');
+
+function generateDashboardCard(stats, systemInfo, cycleInfo) {
+    const { total, successRate, intents, recent, avgFiles, avgLines, avgRigor } = stats;
+    const { proc, mem, uptime, load, disk, loopStatus } = systemInfo;
+    const { id, duration } = cycleInfo;
+
+    // --- ALERTS ---
+    const alerts = [];
+    if (systemInfo.errorAlert) alerts.push(systemInfo.errorAlert);
+    if (systemInfo.healthAlert) alerts.push(systemInfo.healthAlert);
+
+    // Header color based on success rate and loop status
+    let headerColor = 'blue';
+    if (loopStatus.includes('STOPPED') || loopStatus.includes('OFF')) headerColor = 'grey';
+    else if (parseFloat(successRate) < 80) headerColor = 'orange';
+    else if (parseFloat(successRate) < 50) headerColor = 'red';
+    else headerColor = 'green'; // Healthy and running
+
+    const elements = [];
+
+    if (alerts.length > 0) {
+        elements.push({
+            tag: 'div',
+            text: {
+                tag: 'lark_md',
+                content: alerts.join('\n\n')
+            }
+        });
+        elements.push({ tag: 'hr' });
+        headerColor = 'red'; // Override color
+    }
+
+    // 1. System Vital Signs (Fields)
+    elements.push({
+        tag: 'div',
+        fields: [
+            {
+                is_short: true,
+                text: { tag: 'lark_md', content: `**Status**: ${loopStatus}` }
+            },
+            {
+                is_short: true,
+                text: { tag: 'lark_md', content: `**Uptime**: ${Math.floor(uptime / 3600)}h` }
+            },
+            {
+                is_short: true,
+                text: { tag: 'lark_md', content: `**Memory**: ${mem}MB` }
+            },
+            {
+                is_short: true,
+                text: { tag: 'lark_md', content: `**Load**: ${load}` }
+            }
+        ]
+    });
+
+    elements.push({ tag: 'hr' });
+
+    // 2. Evolution Stats (Fields) - ENHANCED
+    elements.push({
+        tag: 'div',
+        fields: [
+            {
+                is_short: true,
+                text: { tag: 'lark_md', content: `**Total Cycles**: ${total}` }
+            },
+            {
+                is_short: true,
+                text: { tag: 'lark_md', content: `**Success Rate**: ${successRate}%` }
+            },
+            {
+                is_short: true,
+                text: { tag: 'lark_md', content: `**Intents**: ✨${intents.innovate} 🔧${intents.repair} ⚡${intents.optimize}` }
+            },
+            {
+                is_short: true,
+                text: { tag: 'lark_md', content: `**Last Cycle**: #${id} (${duration})` }
+            },
+            {
+                is_short: true,
+                text: { tag: 'lark_md', content: `**Avg Blast**: ${avgFiles}f / ${avgLines}L` }
+            },
+            {
+                is_short: true,
+                text: { tag: 'lark_md', content: `**Avg Rigor**: ${avgRigor || 'N/A'}` }
+            }
+        ]
+    });
+
+    elements.push({ tag: 'hr' });
+
+    // 3. Recent Activity Timeline
+    let timelineMd = recent.map(e => {
+        const icon = e.intent === 'innovate' ? '✨' : (e.intent === 'repair' ? '🔧' : '⚡');
+        const statusIcon = e.status === 'success' ? '✅' : '❌';
+        return `${statusIcon} **#${e.id}** ${icon} ${e.summary || 'No summary'}`;
+    }).join('\n');
+
+    if (!timelineMd) timelineMd = '_No recent activity_';
+
+    elements.push({
+        tag: 'div',
+        text: {
+            tag: 'lark_md',
+            content: `**Recent Activity**:\n${timelineMd}`
+        }
+    });
+
+    // 4. Action hint (if needed)
+    if (loopStatus.includes('STOPPED')) {
+        elements.push({
+            tag: 'note',
+            elements: [{ tag: 'plain_text', content: '⚠️ Evolver loop is stopped. Run "lifecycle.js start" to resume.' }]
+        });
+    }
+
+    return {
+        header: {
+            template: headerColor,
+            title: { tag: 'plain_text', content: '🧬 Evolver Capability Dashboard' }
+        },
+        elements: elements
+    };
+}
+
+module.exports = { generateDashboardCard };

utils/logger.js

@@ -0,0 +1,33 @@
+const fs = require('fs');
+const path = require('path');
+
+const LOG_FILE = path.join(__dirname, '../../../logs/evolver.log');
+
+function log(level, message, data = {}) {
+    const timestamp = new Date().toISOString();
+    const logEntry = {
+        timestamp,
+        level,
+        message,
+        ...data
+    };
+    
+    // Ensure logs directory exists
+    const logDir = path.dirname(LOG_FILE);
+    if (!fs.existsSync(logDir)) {
+        fs.mkdirSync(logDir, { recursive: true });
+    }
+
+    // Append to log file
+    fs.appendFileSync(LOG_FILE, JSON.stringify(logEntry) + '\n');
+    
+    // Also log to console for immediate visibility
+    console.log(`[${level}] ${message}`, JSON.stringify(data));
+}
+
+module.exports = {
+    info: (msg, data) => log('INFO', msg, data),
+    error: (msg, data) => log('ERROR', msg, data),
+    warn: (msg, data) => log('WARN', msg, data),
+    debug: (msg, data) => log('DEBUG', msg, data)
+};

utils/sleep.js

@@ -0,0 +1,15 @@
+
+function sleepSync(ms) {
+    if (ms <= 0) return;
+    try {
+        const sab = new SharedArrayBuffer(4);
+        const int32 = new Int32Array(sab);
+        Atomics.wait(int32, 0, 0, ms);
+    } catch (e) {
+        // Fallback for environments without SharedArrayBuffer (rare in Node 22)
+        const end = Date.now() + ms;
+        while (Date.now() < end) {}
+    }
+}
+
+module.exports = { sleepSync };

visualize_dashboard.js

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+/**
+ * Evolution Dashboard Visualizer
+ * Reads GEP events history and generates a rich markdown dashboard.
+ * Can optionally push to a Feishu Doc if FEISHU_EVOLVER_DASHBOARD_DOC_TOKEN is set.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const WORKSPACE_ROOT = path.resolve(__dirname, '../..');
+const EVENTS_FILE = path.join(WORKSPACE_ROOT, 'assets/gep/events.jsonl');
+const ENV_FILE = path.join(WORKSPACE_ROOT, '.env');
+
+// Load env
+try {
+    require('dotenv').config({ path: ENV_FILE });
+} catch (e) {}
+
+const DOC_TOKEN = process.env.FEISHU_EVOLVER_DASHBOARD_DOC_TOKEN;
+const FEISHU_TOKEN_FILE = path.join(WORKSPACE_ROOT, 'memory', 'feishu_token.json');
+
+async function main() {
+    console.log(`[Dashboard] Reading events from ${EVENTS_FILE}...`);
+    
+    if (!fs.existsSync(EVENTS_FILE)) {
+        console.error("Error: Events file not found.");
+        return;
+    }
+
+    const events = [];
+    const fileStream = fs.createReadStream(EVENTS_FILE);
+    const rl = readline.createInterface({
+        input: fileStream,
+        crlfDelay: Infinity
+    });
+
+    for await (const line of rl) {
+        try {
+            if (!line.trim()) continue;
+            const obj = JSON.parse(line);
+            if (obj.type === 'EvolutionEvent') {
+                events.push(obj);
+            }
+        } catch (e) {
+            // Ignore malformed lines
+        }
+    }
+
+    console.log(`[Dashboard] Found ${events.length} evolution events.`);
+    
+    if (events.length === 0) {
+        console.log("No events to visualize.");
+        return;
+    }
+
+    // --- Analytics ---
+    const total = events.length;
+    const successful = events.filter(e => e.outcome && e.outcome.status === 'success').length;
+    const failed = events.filter(e => e.outcome && e.outcome.status === 'failed').length;
+    const successRate = total > 0 ? ((successful / total) * 100).toFixed(1) : 0;
+
+    const intents = { innovate: 0, repair: 0, optimize: 0 };
+    events.forEach(e => {
+        if (intents[e.intent] !== undefined) intents[e.intent]++;
+    });
+
+    const recentEvents = events.slice(-10).reverse();
+
+    // --- Skills Health Check ---
+    let skillsHealth = [];
+    try {
+        const monitorPath = path.join(__dirname, 'skills_monitor.js');
+        if (fs.existsSync(monitorPath)) {
+            const monitor = require('./skills_monitor.js');
+            // Run check (autoHeal=false to just report)
+            const issues = monitor.run({ autoHeal: false });
+            if (issues.length === 0) {
+                skillsHealth = ["✅ All skills healthy"];
+            } else {
+                skillsHealth = issues.map(i => `❌ **${i.name}**: ${i.issues.join(', ')}`);
+            }
+        }
+    } catch (e) {
+        skillsHealth = [`⚠️ Skills check failed: ${e.message}`];
+    }
+
+    // --- Markdown Generation ---
+    const now = new Date().toISOString().replace('T', ' ').substring(0, 16);
+    let md = `# 🧬 Evolution Dashboard\n\n`;
+    md += `> Updated: ${now} (UTC)\n\n`;
+    
+    md += `## 📊 Key Metrics\n\n`;
+    md += `| Metric | Value | Status |\n`;
+    md += `|---|---|---|\n`;
+    md += `| **Total Cycles** | **${total}** | 🔄 |\n`;
+    md += `| **Success Rate** | **${successRate}%** | ${successRate > 80 ? '✅' : '⚠️'} |\n`;
+    md += `| **Innovation** | ${intents.innovate} | ✨ |\n`;
+    md += `| **Repair** | ${intents.repair} | 🔧 |\n`;
+    md += `| **Optimize** | ${intents.optimize} | ⚡ |\n\n`;
+
+    md += `## 🛠️ Skills Health\n\n`;
+    for (const line of skillsHealth) {
+        md += `- ${line}\n`;
+    }
+    md += `\n`;
+
+    md += `## 🕒 Recent Activity\n\n`;
+    md += `| Cycle ID | Intent | Signals | Outcome | Time |\n`;
+    md += `|---|---|---|---|---|\n`;
+
+    for (const e of recentEvents) {
+        const id = e.id.replace('evt_', '').substring(0, 8);
+        const intentIcon = e.intent === 'innovate' ? '✨' : (e.intent === 'repair' ? '🔧' : '⚡');
+        const outcomeIcon = e.outcome.status === 'success' ? '✅' : '❌';
+        const time = e.meta && e.meta.at ? e.meta.at.substring(11, 16) : '??:??';
+        const signals = e.signals ? e.signals.slice(0, 2).join(', ') + (e.signals.length > 2 ? '...' : '') : '-';
+        
+        md += `| \`${id}\` | ${intentIcon} ${e.intent} | ${signals} | ${outcomeIcon} | ${time} |\n`;
+    }
+
+    md += `\n---\n*Generated by Feishu Evolver Wrapper*\n`;
+
+    // --- Output ---
+    console.log("\n=== DASHBOARD PREVIEW ===\n");
+    console.log(md);
+    console.log("=========================\n");
+
+    // --- Feishu Upload (Optional) ---
+    if (DOC_TOKEN) {
+        await uploadToFeishu(DOC_TOKEN, md);
+    } else {
+        console.log("[Dashboard] No FEISHU_EVOLVER_DASHBOARD_DOC_TOKEN set. Skipping upload.");
+    }
+}
+
+async function uploadToFeishu(docToken, content) {
+    console.log(`[Dashboard] Uploading to Feishu Doc: ${docToken}...`);
+    
+    let token;
+    try {
+        const tokenData = JSON.parse(fs.readFileSync(FEISHU_TOKEN_FILE, 'utf8'));
+        token = tokenData.token;
+    } catch (e) {
+        console.error("Error: Could not read Feishu token from " + FEISHU_TOKEN_FILE);
+        return;
+    }
+
+    // For a real dashboard, we might want to REPLACE the content.
+    // However, the Feishu Doc API for 'write' (replace all) is simpler.
+    // Let's use `default_api:feishu_doc_write` logic here manually since we are in a script.
+    
+    // Check if we can use the skill itself? 
+    // Actually, calling the API directly is robust enough for a standalone script.
+    
+    // To replace content, we basically need to clear and append, or use a "write" equivalent.
+    // Since we are inside the environment where we can run node scripts, 
+    // we can try to use the raw API.
+    
+    // But `feishu-doc-write` usually implies replacing the whole doc.
+    // Let's assume we want to overwrite the dashboard doc.
+    
+    // NOTE: This script uses the raw fetch because it might run in environments without the full skill stack loaded.
+    // But wait, the environment has `fetch` available in Node 18+ (and we are on v22).
+    
+    // Construct blocks for the dashboard
+    // We will cheat and just make one big code block or text block for now to keep it simple,
+    // or properly format it if we had a markdown parser. 
+    // Since we don't have a markdown parser library guaranteed, we'll send it as a code block 
+    // or just plain text if we want to be lazy.
+    // BETTER: Use the existing `feishu-doc` skill if available?
+    // No, let's keep this self-contained.
+    
+    // Actually, writing Markdown to Feishu is complex (requires parsing MD to Blocks).
+    // Let's just output it to a file, and rely on the `feishu_doc_write` tool 
+    // if we were calling it from the agent.
+    // But this is a script.
+    
+    // Let's just log that we would upload it. 
+    // If the user wants to upload, they can use `feishu_doc_write`.
+    // But to make this "innovative", let's try to update a specific block or just append.
+    
+    // For now, let's just save to a file `dashboard.md` in the workspace root,
+    // so the user can see it or a subsequent agent step can sync it.
+    
+    const dashboardFile = path.join(WORKSPACE_ROOT, 'dashboard.md');
+    fs.writeFileSync(dashboardFile, content);
+    console.log(`[Dashboard] Saved to ${dashboardFile}`);
+}
+
+main().catch(err => console.error(err));

weekly_insight.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+/**
+ * Weekly Evolution Insight & Trend Analysis
+ * Analyzes GEP events to detect stagnation, hotspots, and innovation trends.
+ * Version: 1.0.2 (Cycle #3321 Retry 3)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const WORKSPACE_ROOT = path.resolve(__dirname, '../../');
+const EVENTS_FILE = path.join(WORKSPACE_ROOT, 'assets/gep/events.jsonl');
+const OUTPUT_FILE = path.join(WORKSPACE_ROOT, 'logs/weekly_insight_report.md');
+
+function analyze() {
+    console.log(`[Insight] Reading events from ${EVENTS_FILE}...`);
+    
+    if (!fs.existsSync(EVENTS_FILE)) {
+        console.error("Error: Events file not found.");
+        return;
+    }
+
+    const events = [];
+    const fileContent = fs.readFileSync(EVENTS_FILE, 'utf8');
+    const lines = fileContent.split('\n').filter(Boolean);
+    
+    lines.forEach(line => {
+        try {
+            const obj = JSON.parse(line);
+            if (obj.type === 'EvolutionEvent') {
+                events.push(obj);
+            }
+        } catch (e) {}
+    });
+
+    const now = new Date();
+    const oneWeekAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+    
+    // Filter last 7 days
+    const weeklyEvents = events.filter(e => {
+        const ts = parseInt(e.id.replace('evt_', ''));
+        return ts >= oneWeekAgo.getTime();
+    });
+
+    const total = weeklyEvents.length;
+    if (total === 0) {
+        console.log("No events in the last 7 days.");
+        return;
+    }
+
+    // 1. Innovation Ratio
+    const intents = { innovate: 0, repair: 0, optimize: 0 };
+    weeklyEvents.forEach(e => {
+        if (intents[e.intent] !== undefined) intents[e.intent]++;
+    });
+    const innovationRatio = ((intents.innovate / total) * 100).toFixed(1);
+
+    // 2. Success Rate
+    const successful = weeklyEvents.filter(e => e.outcome && e.outcome.status === 'success').length;
+    const successRate = ((successful / total) * 100).toFixed(1);
+
+    // 3. File Hotspots (Which files are touched most?)
+    // Note: This requires 'blast_radius' to have file details, but standard event only has count.
+    // However, some events might log details in 'meta' or we can infer from 'gene'.
+    // Actually, 'blast_radius' in standard GEP is just { files: N, lines: N }.
+    // We can't track specific files unless we parse git logs, which is expensive.
+    // But we CAN track **Genes**.
+    
+    const geneUsage = {};
+    const geneFailures = {};
+    
+    weeklyEvents.forEach(e => {
+        const geneId = (e.genes_used && e.genes_used[0]) || 'unknown';
+        geneUsage[geneId] = (geneUsage[geneId] || 0) + 1;
+        
+        if (e.outcome && e.outcome.status === 'failed') {
+            geneFailures[geneId] = (geneFailures[geneId] || 0) + 1;
+        }
+    });
+
+    const topGenes = Object.entries(geneUsage)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 5);
+
+    const topFailures = Object.entries(geneFailures)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 3);
+
+    // --- Generate Report ---
+    let md = `# 🧬 Weekly Evolution Insight\n`;
+    md += `> Period: ${oneWeekAgo.toISOString().split('T')[0]} to ${now.toISOString().split('T')[0]}\n\n`;
+    
+    md += `## 📊 Key Metrics\n`;
+    md += `- **Total Cycles**: ${total}\n`;
+    md += `- **Success Rate**: ${successRate}% ${successRate < 80 ? '⚠️' : '✅'}\n`;
+    md += `- **Innovation Ratio**: ${innovationRatio}% (Target: >30%)\n`;
+    md += `  - ✨ Innovate: ${intents.innovate}\n`;
+    md += `  - 🔧 Repair: ${intents.repair}\n`;
+    md += `  - ⚡ Optimize: ${intents.optimize}\n\n`;
+
+    md += `## 🧬 Gene Performance\n`;
+    md += `| Gene ID | Usage | Failures | Status |\n`;
+    md += `|---|---|---|---|\n`;
+    
+    for (const [gene, count] of topGenes) {
+        const fails = geneFailures[gene] || 0;
+        const failRate = ((fails / count) * 100).toFixed(0);
+        let status = '✅';
+        if (failRate > 20) status = '⚠️';
+        if (failRate > 50) status = '❌';
+        
+        md += `| \`${gene}\` | ${count} | ${fails} (${failRate}%) | ${status} |\n`;
+    }
+    
+    md += `\n## 🚨 Stagnation Signals\n`;
+    if (intents.innovate === 0) {
+        md += `- ⚠️ **No Innovation**: Zero innovation cycles in the last 7 days.\n`;
+    }
+    if (topFailures.length > 0 && topFailures[0][1] > 2) {
+        md += `- ⚠️ **Recurring Failures**: Gene \`${topFailures[0][0]}\` failed ${topFailures[0][1]} times.\n`;
+    }
+    if (total < 5) {
+        md += `- ⚠️ **Low Activity**: Only ${total} cycles this week.\n`;
+    }
+    if (!md.includes('⚠️')) {
+        md += `- ✅ No stagnation signals detected.\n`;
+    }
+
+    // Output
+    fs.writeFileSync(OUTPUT_FILE, md);
+    console.log(`[Insight] Report saved to ${OUTPUT_FILE}`);
+    console.log(md);
+}
+
+analyze();