Feishu Evolver Wrapper

{
  "ownerId": "kn7apafdj4thknczrgxdzfd2v1808svf",
  "slug": "feishu-evolver-wrapper",
  "version": "1.6.1",
  "publishedAt": 1771169237506
}

{
  "version": 1,
  "registry": "https://clawhub.ai",
  "slug": "feishu-evolver-wrapper",
  "installedVersion": "1.6.1",
  "installedAt": 1771251431305
}

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

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

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

#!/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

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, (error, stdout, stderr) => {
    EXEC_CACHE.set(command, { timestamp: Date.now(), error, stdout, stderr });
    callback(error, stdout, stderr);
  });
}

module.exports = { cachedExec };

#!/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 };

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

#!/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 }
        );
        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 tmpFile = path.join('/tmp', `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 }
        );
        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 };

#!/usr/bin/env node
const { execSync, spawn } = require('child_process');
const fs = require('fs');
const path = require('path');
const logger = require('./utils/logger'); // New logger

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: true,
        stdio: ['ignore', out, err],
        cwd: __dirname
    });
    
    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' });
        } 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: true,
                stdio: 'ignore', // Ignore output to reduce IO
                cwd: __dirname
            });
            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 {
                    execSync(`which ${openclawCli}`, { stdio: 'ignore' });
                    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 });
            } 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);
              console.log('[Lifecycle] Watchdog cron job created successfully.');
            } else {
              // If disabled, enable it
              if (exists.enabled === false) {
                 console.log(`[Lifecycle] Enabling disabled watchdog job (ID: ${exists.id})...`);
                 execSync(`${openclawCli} cron edit "${exists.id}" --enable`);
              }
              // Optimization: Enforce 30m interval if currently 10m (reduce exec usage)
              if (exists.schedule && exists.schedule.everyMs === 600000) {
                 console.log(`[Lifecycle] Optimizing watchdog frequency to 30m (ID: ${exists.id})...`);
                 // Use cron update with patch
                 // FIXED: Use --every instead of invalid --patch
                 execSync(`${openclawCli} cron edit "${exists.id}" --every "30m"`);
              }
            }
            // 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: true,
    stdio: ['ignore', out, err],
    cwd: __dirname
  });
  
  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' });
             }
         } 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' });
             }
         } 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' });
                }
            } 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' });
        }
    } 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();
}

{
  "name": "feishu-evolver-wrapper",
  "version": "1.6.0",
  "description": "Feishu-specific wrapper for capability-evolver",
  "main": "index.js",
  "dependencies": {
    "evolver": "file:../evolver"
  }
}

#!/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
                return execSync('ps -e | wc -l').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
                return execSync(`df -h "${mount || '/'}" | tail -1 | awk '{print $5}'`).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'] }).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 };