#!/usr/bin/env node

// Load .env BEFORE any internal require so that a2aProtocol and ATP

// modules see A2A_NODE_SECRET / A2A_NODE_ID / A2A_HUB_URL at first

// access and never fall back to a stale persisted/cached secret.

// Reported in #460.

//

// Load order matters (see #526): we must not call getRepoRoot() before

// .env is loaded, otherwise EVOLVER_REPO_ROOT set in .env is silently

// ignored because getRepoRoot() caches the .git-walk result on first

// call. Strategy:

// 1. Try .env at process.cwd() first. This is where a user running

// `evolver` from their project root expects the file, and it is

// independent of getRepoRoot() caching.

// 2. Read EVOLVER_REPO_ROOT from process.env (dotenv just populated it

// if set in cwd/.env).

// 3. Only now call getRepoRoot(), which will honor EVOLVER_REPO_ROOT

// if present; then try .env at that root as well (dotenv never

// overwrites already-set keys, so step 1 wins when both exist).

try {

const _path = require('path');

// Step 1: load .env from process.cwd() before any internal require.

// Matches the regression test for #460 which asserts

// `require('dotenv').config` appears before any ./src/* require other

// than ./src/gep/paths.

require('dotenv').config({ path: _path.join(process.cwd(), '.env') });

// Suppress the "Using host git repository at" banner during bootstrap.

// If .env at the discovered root overrides EVOLVER_REPO_ROOT, the

// initial banner would point at the wrong path and mislead users

// debugging the very chicken-and-egg problem #526 reported. The banner

// prints for real when getRepoRoot() is called later by application code.

const _prevQuiet = process.env.EVOLVER_QUIET_PARENT_GIT;

process.env.EVOLVER_QUIET_PARENT_GIT = '1';

const { getRepoRoot: _getRepoRoot } = require('./src/gep/paths');

const _root = _getRepoRoot();

if (_root && _root !== process.cwd()) {

require('dotenv').config({ path: _path.join(_root, '.env') });

}

if (_prevQuiet === undefined) delete process.env.EVOLVER_QUIET_PARENT_GIT;

else process.env.EVOLVER_QUIET_PARENT_GIT = _prevQuiet;

} catch (e) { /* dotenv is optional */ }

const evolve = require('./src/evolve');

const { solidify } = require('./src/gep/solidify');

const path = require('path');

const { getRepoRoot } = require('./src/gep/paths');

const fs = require('fs');

const { spawn } = require('child_process');

function sleepMs(ms) {

const n = parseInt(String(ms), 10);

const t = Number.isFinite(n) ? Math.max(0, n) : 0;

return new Promise(resolve => setTimeout(resolve, t));

}

function readJsonSafe(p) {

try {

if (!fs.existsSync(p)) return null;

const raw = fs.readFileSync(p, 'utf8');

if (!raw.trim()) return null;

return JSON.parse(raw);

} catch (e) {

return null;

}

}

/**

* Mark a pending evolution run as rejected (state-only, no git rollback).

* @param {string} statePath - Path to evolution_solidify_state.json

* @returns {boolean} true if a pending run was found and rejected

*/

function rejectPendingRun(statePath) {

try {

const state = readJsonSafe(statePath);

if (state && state.last_run && state.last_run.run_id) {

state.last_solidify = {

run_id: state.last_run.run_id,

rejected: true,

reason: 'loop_bridge_disabled_autoreject_no_rollback',

timestamp: new Date().toISOString(),

};

const tmp = `${statePath}.tmp`;

fs.writeFileSync(tmp, JSON.stringify(state, null, 2) + '\n', 'utf8');

fs.renameSync(tmp, statePath);

return true;

}

} catch (e) {

console.warn('[Loop] Failed to clear pending run state: ' + (e.message || e));

}

return false;

}

function isPendingSolidify(state) {

const lastRun = state && state.last_run ? state.last_run : null;

const lastSolid = state && state.last_solidify ? state.last_solidify : null;

if (!lastRun || !lastRun.run_id) return false;

if (!lastSolid || !lastSolid.run_id) return true;

return String(lastSolid.run_id) !== String(lastRun.run_id);

}

function parseMs(v, fallback) {

const n = parseInt(String(v == null ? '' : v), 10);

if (Number.isFinite(n)) return Math.max(0, n);

return fallback;

}

function parseBoolEnv(v, fallback) {

if (v == null) return fallback;

const s = String(v).toLowerCase().trim();

if (s === '' ) return fallback;

if (s === 'false' || s === '0' || s === 'off' || s === 'no') return false;

if (s === 'true' || s === '1' || s === 'on' || s === 'yes') return true;

return fallback;

}

class CycleTimeoutError extends Error {

constructor(timeoutMs, phase, cycleNum) {

super('Cycle hard-timeout exceeded after ' + timeoutMs + 'ms (cycle=' + cycleNum + ', phase=' + phase + ')');

this.name = 'CycleTimeoutError';

this.code = 'CYCLE_TIMEOUT';

this.timeoutMs = timeoutMs;

this.phase = phase;

this.cycleNum = cycleNum;

}

}

// Issue #528: on Windows, child_process.spawn(detached: true, windowsHide: true)

// allocates a new conhost window every time -- windowsHide is silently ignored

// in detached mode. So suicide-respawn (cycles >= max, RSS over budget, or the

// new cycle hard-timeout) opens a new cmd popup on every restart. We now skip

// the in-process detached spawn on Windows by default and rely on an external

// supervisor (NSSM, pm2-windows, etc.) to respawn the daemon on non-zero exit.

// Users who insist can opt back in with EVOLVER_SUICIDE_WINDOWS=true (and accept

// the popups).

function spawnReplacementProcess({ reason, args, logPath }) {

const isWindows = process.platform === 'win32';

const allowOnWindows = parseBoolEnv(process.env.EVOLVER_SUICIDE_WINDOWS, false);

if (isWindows && !allowOnWindows) {

console.log(

'[Daemon] Skipping in-process respawn on Windows (' + reason + '). ' +

'Native Node spawn(detached, windowsHide) opens a cmd popup on every restart (Issue #528). ' +

'Set EVOLVER_SUICIDE_WINDOWS=true to opt back in. ' +

'Recommended: run evolver under an external supervisor (NSSM, pm2-windows, etc.) so it restarts on exit.'

);

return { spawned: false, reason: 'windows_default_skip' };

}

try {

const logFd = fs.openSync(logPath, 'a');

const spawnOpts = {

detached: true,

stdio: ['ignore', logFd, logFd],

env: process.env,

windowsHide: true,

};

const child = spawn(process.execPath, [__filename, ...args], spawnOpts);

child.unref();

return { spawned: true };

} catch (e) {

console.error('[Daemon] Spawn-replacement failed (' + reason + '): ' + (e && e.message || e));

return { spawned: false, reason: 'spawn_error', error: e };

}

}

// Atomic write of the cycle_progress.json file. Wrapper polls this file every

// 60s; if updated_at goes stale beyond EVOLVE_INNER_STUCK_TIMEOUT_SEC the

// wrapper treats the inner core as zombie and SIGKILLs it. See Issue #19 (the

// 22-day stuck-cycle incident) and the cross-repo timeout plan for context.

function writeCycleProgressAtomic(progressPath, fields) {

try {

const data = Object.assign({}, fields, { updated_at: Date.now() });

const tmp = progressPath + '.tmp.' + process.pid;

fs.writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n', 'utf8');

fs.renameSync(tmp, progressPath);

return true;

} catch (e) {

return false;

}

}

function getLastSignals(statePath) {

try {

const st = readJsonSafe(statePath);

return (st && st.last_run && Array.isArray(st.last_run.signals)) ? st.last_run.signals : [];

} catch (e) {

return [];

}

}

// Singleton Guard - prevent multiple evolver daemon instances

function acquireLock() {

const lockFile = path.join(__dirname, 'evolver.pid');

try {

try {

fs.writeFileSync(lockFile, String(process.pid), { flag: 'wx' });

return true;

} catch (exclErr) {

if (exclErr.code !== 'EEXIST') throw exclErr;

}

const pid = parseInt(fs.readFileSync(lockFile, 'utf8').trim(), 10);

if (!Number.isFinite(pid) || pid <= 0) {

console.log('[Singleton] Corrupt lock file (invalid PID). Taking over.');

} else {

try {

process.kill(pid, 0);

console.log(`[Singleton] Evolver loop already running (PID ${pid}). Exiting.`);

return false;

} catch (e) {

console.log(`[Singleton] Stale lock found (PID ${pid}). Taking over.`);

}

}

fs.writeFileSync(lockFile, String(process.pid));

return true;

} catch (err) {

console.error('[Singleton] Lock acquisition failed:', err);

return false;

}

}

function releaseLock() {

const lockFile = path.join(__dirname, 'evolver.pid');

try {

if (fs.existsSync(lockFile)) {

const pid = parseInt(fs.readFileSync(lockFile, 'utf8').trim(), 10);

if (pid === process.pid) fs.unlinkSync(lockFile);

}

} catch (e) { /* ignore */ }

}

async function main() {

const args = process.argv.slice(2);

const command = args[0];

const isLoop = args.includes('--loop') || args.includes('--mad-dog');

const isVerbose = args.includes('--verbose') || args.includes('-v') ||

String(process.env.EVOLVER_VERBOSE || '').toLowerCase() === 'true';

if (isVerbose) process.env.EVOLVER_VERBOSE = 'true';

if (!command || command === 'run' || command === '/evolve' || isLoop) {

if (isLoop) {

const originalLog = console.log;

const originalWarn = console.warn;

const originalError = console.error;

function ts() { return '[' + new Date().toISOString() + ']'; }

console.log = (...args) => { originalLog.call(console, ts(), ...args); };

console.warn = (...args) => { originalWarn.call(console, ts(), ...args); };

console.error = (...args) => { originalError.call(console, ts(), ...args); };

}

console.log('Starting evolver...');

// Preflight: fail fast if git is not on PATH. On Windows in particular

// a missing git binary can cause evolver to hang silently (see #394),

// because several cycle-critical steps shell out to git early (repo

// resolution, diff, blast-radius). Catching this up front makes the

// failure mode obvious.

try {

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

execSync('git --version', { stdio: 'ignore', timeout: 5000 });

} catch (_gitErr) {

console.error('');

console.error('[Preflight] Could not run "git --version". Evolver requires git to be installed and available on PATH.');

console.error('[Preflight] On Windows: install Git from https://git-scm.com/download/win and make sure `git --version` works in a fresh terminal.');

console.error('[Preflight] On macOS: xcode-select --install (or `brew install git`)');

console.error('[Preflight] On Linux: sudo apt-get install -y git (or your distro equivalent)');

console.error('');

process.exit(1);

}

if (isLoop) {

// Internal daemon loop (no wrapper required).

if (!acquireLock()) process.exit(0);

function shutdown() {

releaseLock();

try { require('./src/gep/a2aProtocol').stopEventStream(); } catch (e) {}

}

process.on('exit', shutdown);

process.on('SIGINT', () => { shutdown(); process.exit(); });

process.on('SIGTERM', () => { shutdown(); process.exit(); });

process.on('uncaughtException', (err) => {

console.error('[FATAL] Uncaught exception:', err && err.stack ? err.stack : String(err));

releaseLock();

process.exit(1);

});

let _unhandledRejectionCount = 0;

process.on('unhandledRejection', (reason) => {

_unhandledRejectionCount++;

console.error('[FATAL] Unhandled promise rejection (' + _unhandledRejectionCount + '):', reason && reason.stack ? reason.stack : String(reason));

if (_unhandledRejectionCount >= 5) {

console.error('[FATAL] Too many unhandled rejections (' + _unhandledRejectionCount + '). Exiting to avoid corrupt state.');

releaseLock();

process.exit(1);

}

});

process.env.EVOLVE_LOOP = 'true';

if (!process.env.EVOLVE_BRIDGE) {

process.env.EVOLVE_BRIDGE = 'false';

}

console.log(`Loop mode enabled (internal daemon, bridge=${process.env.EVOLVE_BRIDGE}, verbose=${isVerbose}).`);

// Startup diagnostic: in daemon mode evolver consumes its own stdout

// instead of handing `sessions_spawn(...)` directives to a host

// runtime (OpenClaw). If the operator expects real-time agent assist

// they are likely using the wrong mode; if they intend daemon mode

// they still need AGENT_NAME / AGENT_SESSIONS_DIR pointing at a live

// agent or the loop will just cycle on its own logs. Emit a single

// warning at startup so "empty cycling" has a visible breadcrumb.

try {

const { diagnoseSessionSourceEmpty } = require('./src/evolve');

const diag = diagnoseSessionSourceEmpty();

const hasAnySource = diag.agentSessionsDirExists ||

diag.cursorDirExists || diag.claudeDirExists || diag.codexDirExists ||

Boolean(diag.cursorTranscriptsDir);

if (!hasAnySource) {

console.warn('[Daemon] No session sources detected at startup. Loop mode runs background self-maintenance but cannot observe a live agent without at least one of:');

console.warn(` - ~/.openclaw/agents/<AGENT_NAME>/sessions/ (current AGENT_NAME=${diag.agentName}, exists=${diag.agentSessionsDirExists})`);

console.warn(' - ~/.cursor / ~/.claude / ~/.codex (IDE transcripts)');

console.warn(' - EVOLVER_CURSOR_TRANSCRIPTS_DIR (explicit override)');

if (diag.availableOpenClawAgents.length > 0) {

console.warn(` Available OpenClaw agents under ~/.openclaw/agents/: ${diag.availableOpenClawAgents.join(', ')}`);

console.warn(' Set AGENT_NAME=<agent> or AGENT_SESSIONS_DIR=<abs path> to the one actually doing work.');

}

for (const hint of diag.hints) {

console.warn(` HINT: ${hint}`);

}

console.warn(' If you want real-time agent assist (not background self-maintenance), run `evolver run` from inside the agent session instead of `evolver --loop`.');

}

} catch (_diagErr) { /* diagnostics must never block startup */ }

// Hub outcome mirror diagnostic. memoryGraph.syncEventToHub posts every

// outcome/attempt/solidify/skill_emit event to <hub>/a2a/memory/event

// by default, which is what populates this node's recall stream from

// the Hub side (consumed by gep-mcp-server's gep_recall). It is silent

// best-effort: failures don't crash the daemon but also don't surface,

// so users get a "why does gep_recall return 0 matches" puzzle. A

// single startup line says explicitly whether the mirror is on, what

// node it would post as, and what to flip if you want it off.

try {

const a2a = require('./src/gep/a2aProtocol');

const mirrorOff = process.env.MEMORY_GRAPH_SYNC_HUB === '0';

const hubUrl = typeof a2a.getHubUrl === 'function' ? a2a.getHubUrl() : '';

const nodeId = typeof a2a.getNodeId === 'function' ? a2a.getNodeId() : '';

const hasSecret = typeof a2a.getHubNodeSecret === 'function' && !!a2a.getHubNodeSecret();

if (mirrorOff) {

console.log('[HubMirror] DISABLED — set MEMORY_GRAPH_SYNC_HUB=1 (or unset it) to mirror outcome events to <hub>/a2a/memory/event.');

} else if (!hubUrl || !nodeId || !hasSecret) {

console.log(`[HubMirror] inactive — missing one of: hub=${hubUrl ? 'OK' : 'MISSING'} node_id=${nodeId ? 'OK' : 'MISSING'} secret=${hasSecret ? 'OK' : 'MISSING'}. Local memory graph is unaffected.`);

} else {

console.log(`[HubMirror] ENABLED — outcome/attempt/solidify/skill_emit events mirror to ${hubUrl}/a2a/memory/event as ${nodeId}. Set MEMORY_GRAPH_SYNC_HUB=0 to disable.`);

}

} catch (_mirrorDiagErr) { /* diagnostics must never block startup */ }

// RecallVerify diagnostic banner: parallel to HubMirror but reads its

// own env, since verification can run with HubMirror off (verifier

// events are local-only on first ship).

try {

const enabled = String(process.env.EVOLVE_RECALL_VERIFY || '1') !== '0';

const sampleRateRaw = Number(process.env.EVOLVE_RECALL_VERIFY_SAMPLE_RATE);

const sampleRate = Number.isFinite(sampleRateRaw) && sampleRateRaw >= 0 && sampleRateRaw <= 1 ? sampleRateRaw : 1.0;

if (!enabled) {

console.log('[RecallVerify] DISABLED — set EVOLVE_RECALL_VERIFY=1 to verify published assets round-trip via Hub Phase 2 lookup.');

} else {

console.log(`[RecallVerify] ENABLED — verifying published assets via Hub Phase 2 lookup, sample_rate=${sampleRate}. Set EVOLVE_RECALL_VERIFY=0 to disable.`);

}

} catch (_rvDiagErr) { /* diagnostics must never block startup */ }

const { getEvolutionDir, getEvolverLogPath } = require('./src/gep/paths');

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

const cycleProgressPath = path.join(getEvolutionDir(), 'cycle_progress.json');

const minSleepMs = parseMs(process.env.EVOLVER_MIN_SLEEP_MS, 2000);

const maxSleepMs = parseMs(process.env.EVOLVER_MAX_SLEEP_MS, 300000);

const idleThresholdMs = parseMs(process.env.EVOLVER_IDLE_THRESHOLD_MS, 500);

const pendingSleepMs = parseMs(

process.env.EVOLVE_PENDING_SLEEP_MS ||

process.env.EVOLVE_MIN_INTERVAL,

120000

);

const maxCyclesPerProcess = parseMs(process.env.EVOLVER_MAX_CYCLES_PER_PROCESS, 100) || 100;

const maxRssMb = parseMs(process.env.EVOLVER_MAX_RSS_MB, 500) || 500;

const suicideEnabled = String(process.env.EVOLVER_SUICIDE || '').toLowerCase() !== 'false';

// Issue #19: hard timeout around evolve.run() to break out of zombie

// cycles (e.g. unclosed socket / stuck LLM call). On timeout we throw

// CycleTimeoutError, log diagnostic stderr, and force suicide-respawn

// so the wrapper sees a fresh PID + cycle. Also write cycle_progress

// every progressUpdateMs so the wrapper has a true heartbeat to poll.

const cycleTimeoutEnabled = parseBoolEnv(process.env.EVOLVER_CYCLE_TIMEOUT_ENABLED, true);

const cycleTimeoutMs = parseMs(process.env.EVOLVER_CYCLE_TIMEOUT_MS, 2700000); // 45 min default

const progressUpdateMs = parseMs(process.env.EVOLVER_PROGRESS_UPDATE_MS, 60000); // 1 min default

// Start hub heartbeat (keeps node alive independently of evolution cycles)

try {

if (process.env.EVOMAP_PROXY === '1' || process.env.A2A_TRANSPORT === 'mailbox') {

const { startProxy } = require('./src/proxy');

const proxyInfo = await startProxy({

hubUrl: process.env.A2A_HUB_URL,

});

console.log('[Proxy] Started on ' + proxyInfo.url);

const { registerMailboxTransport } = require('./src/gep/mailboxTransport');

registerMailboxTransport();

process.env.A2A_TRANSPORT = 'mailbox';

} else {

const a2a = require('./src/gep/a2aProtocol');

try { a2a.startHeartbeat(); }

catch (hbErr) { console.warn('[Heartbeat] startHeartbeat failed: ' + (hbErr && hbErr.message || hbErr)); }

try { a2a.startEventStream(); }

catch (ssErr) { console.warn('[SSE] startEventStream failed: ' + (ssErr && ssErr.message || ssErr)); }

}

} catch (e) {

console.warn('[Heartbeat] Failed to start: ' + (e.message || e));

}

// RecallVerify worker: starts once per process; drains the publish-

// verification queue with backoff. unref'd so it never blocks exit.

try {

if (String(process.env.EVOLVE_RECALL_VERIFY || '1') !== '0') {

require('./src/gep/recallVerifier').startWorker();

}

} catch (rvStartErr) {

console.warn('[RecallVerify] startWorker failed: ' + (rvStartErr && rvStartErr.message || rvStartErr));

}

// Validator daemon: independent timer that fetches and executes

// validation tasks regardless of the main evolve loop's idle gating.

// Honors EVOLVER_VALIDATOR_ENABLED and the persisted feature flag.

try {

const { startValidatorDaemon } = require('./src/gep/validator');

if (startValidatorDaemon()) {

console.log('[ValidatorDaemon] started.');

}

} catch (vdErr) {

console.warn('[ValidatorDaemon] failed to start: ' + (vdErr && vdErr.message || vdErr));

}

// ATP: auto-start merchant agent if enabled

try {

const { defaultHandler, merchantAgent } = require('./src/atp');

const atpMode = defaultHandler.getAtpMode();

if (atpMode === 'auto' || atpMode === 'on') {

const hubUrl = process.env.A2A_HUB_URL || process.env.EVOMAP_HUB_URL || '';

if (hubUrl) {

const services = defaultHandler.resolveAtpServices();

merchantAgent.start({

services: services,

onOrder: defaultHandler.defaultOrderHandler,

pollMs: 30000,

}).catch(function (atpErr) {

console.warn('[ATP] merchantAgent.start failed: ' + (atpErr && atpErr.message || atpErr));

});

}

}

} catch (atpInitErr) {

console.warn('[ATP] Auto-init failed: ' + (atpInitErr && atpInitErr.message || atpInitErr));

}

// ATP: capability-gap auto-buyer. Default ON as of ATP liquidity

// unlock; disable with EVOLVER_ATP_AUTOBUY=off. Also starts the

// merchant-side auto-deliver daemon so claimed ATP tasks actually

// call submitDelivery and settle instead of expiring.

try {

try {

const { runPrompt } = require('./src/atp/cliAutobuyPrompt');

await runPrompt();

} catch (promptErr) {

console.warn('[ATP-AutoBuyer] first-run prompt failed: ' + (promptErr && promptErr.message || promptErr));

}

const autoBuyRaw = (process.env.EVOLVER_ATP_AUTOBUY || 'on').toLowerCase().trim();

const autoBuyOn = autoBuyRaw !== 'off' && autoBuyRaw !== '0' && autoBuyRaw !== 'false';

if (autoBuyOn) {

const hubUrl = process.env.A2A_HUB_URL || process.env.EVOMAP_HUB_URL || '';

if (hubUrl) {

const { autoBuyer } = require('./src/atp');

autoBuyer.start({

dailyCap: Number(process.env.ATP_AUTOBUY_DAILY_CAP_CREDITS) || undefined,

perOrderCap: Number(process.env.ATP_AUTOBUY_PER_ORDER_CAP_CREDITS) || undefined,

});

} else {

console.warn('[ATP-AutoBuyer] autobuy enabled but no hub URL configured, skipping.');

}

}

const autoDeliverRaw = (process.env.EVOLVER_ATP_AUTODELIVER || 'on').toLowerCase().trim();

const autoDeliverOn = autoDeliverRaw !== 'off' && autoDeliverRaw !== '0' && autoDeliverRaw !== 'false';

if (autoDeliverOn) {

const hubUrl = process.env.A2A_HUB_URL || process.env.EVOMAP_HUB_URL || '';

if (hubUrl) {

const autoDeliver = require('./src/atp/autoDeliver');

autoDeliver.start({

pollMs: Number(process.env.ATP_AUTODELIVER_POLL_MS) || undefined,

});

} else {

console.warn('[ATP-AutoDeliver] autodeliver enabled but no hub URL configured, skipping.');

}

}

} catch (autoBuyInitErr) {

console.warn('[ATP-AutoBuyer] Init failed: ' + (autoBuyInitErr && autoBuyInitErr.message || autoBuyInitErr));

}

// Hoist module refs used inside the loop to avoid repeated module lookups per cycle

const idleScheduler = require('./src/gep/idleScheduler');

const { shouldDistillFromFailures: shouldDF, autoDistillFromFailures: autoDF } = require('./src/gep/skillDistiller');

const { tryExplore } = require('./src/gep/explore');

let currentSleepMs = minSleepMs;

let cycleCount = 0;

while (true) {

try {

cycleCount += 1;

// Ralph-loop gating: do not run a new cycle while previous run is pending solidify.

const st0 = readJsonSafe(solidifyStatePath);

if (isPendingSolidify(st0)) {

await sleepMs(Math.max(pendingSleepMs, minSleepMs));

continue;

}

const t0 = Date.now();

let ok = false;

// Issue #19: write progress at cycle start, refresh it every

// progressUpdateMs (default 60s) while evolve.run() is active, and

// wrap evolve.run() with Promise.race(timeout) so a hung internal

// call cannot freeze the daemon for days.

writeCycleProgressAtomic(cycleProgressPath, {

pid: process.pid,

outer_cycle: cycleCount,

inner_cycle: cycleCount,

started_at: t0,

phase: 'evolve.run',

});

let progressTicker = null;

if (progressUpdateMs > 0) {

progressTicker = setInterval(function () {

writeCycleProgressAtomic(cycleProgressPath, {

pid: process.pid,

outer_cycle: cycleCount,

inner_cycle: cycleCount,

started_at: t0,

phase: 'evolve.run',

});

}, progressUpdateMs);

if (typeof progressTicker.unref === 'function') progressTicker.unref();

}

let cycleTimeoutHandle = null;

let cycleTimedOut = false;

try {

const evolvePromise = evolve.run();

if (cycleTimeoutEnabled && cycleTimeoutMs > 0) {

const timeoutPromise = new Promise(function (_, reject) {

cycleTimeoutHandle = setTimeout(function () {

cycleTimedOut = true;

reject(new CycleTimeoutError(cycleTimeoutMs, 'evolve.run', cycleCount));

}, cycleTimeoutMs);

if (cycleTimeoutHandle && typeof cycleTimeoutHandle.unref === 'function') cycleTimeoutHandle.unref();

});

await Promise.race([evolvePromise, timeoutPromise]);

} else {

await evolvePromise;

}

ok = true;

if (String(process.env.EVOLVE_BRIDGE || '').toLowerCase() === 'false') {

const stAfterRun = readJsonSafe(solidifyStatePath);

if (isPendingSolidify(stAfterRun)) {

const cleared = rejectPendingRun(solidifyStatePath);

if (cleared) {

console.warn('[Loop] Auto-rejected pending run because bridge is disabled in loop mode (state only, no rollback).');

}

}

}

} catch (error) {

const msg = error && error.message ? String(error.message) : String(error);

if (error && error.code === 'CYCLE_TIMEOUT') {

console.error('[Daemon] ' + msg);

if (progressTicker) { clearInterval(progressTicker); progressTicker = null; }

if (cycleTimeoutHandle) { clearTimeout(cycleTimeoutHandle); cycleTimeoutHandle = null; }

writeCycleProgressAtomic(cycleProgressPath, {

pid: process.pid,

outer_cycle: cycleCount,

inner_cycle: cycleCount,

started_at: t0,

phase: 'cycle_timeout_respawn',

});

spawnReplacementProcess({

reason: 'cycle_hard_timeout',

args: args,

logPath: getEvolverLogPath(),

});

releaseLock();

process.exit(1);

}

console.error(`Evolution cycle failed: ${msg}`);

} finally {

if (progressTicker) { clearInterval(progressTicker); progressTicker = null; }

if (cycleTimeoutHandle) { clearTimeout(cycleTimeoutHandle); cycleTimeoutHandle = null; }

}

const dt = Date.now() - t0;

// Adaptive sleep: treat very fast cycles as "idle", backoff; otherwise reset to min.

if (!ok || dt < idleThresholdMs) {

currentSleepMs = Math.min(maxSleepMs, Math.max(minSleepMs, currentSleepMs * 2));

} else {

currentSleepMs = minSleepMs;

}

// OMLS-inspired idle scheduling: adjust sleep and trigger aggressive

// operations (distillation, reflection) during detected idle windows.

let omlsMultiplier = 1;

try {

const schedule = idleScheduler.getScheduleRecommendation();

if (schedule.enabled && schedule.sleep_multiplier > 0) {

omlsMultiplier = schedule.sleep_multiplier;

if (schedule.should_distill) {

try {

if (shouldDF()) {

const dfResult = autoDF();

if (dfResult && dfResult.ok) {

console.log('[OMLS] Idle-window failure distillation: ' + dfResult.gene.id);

}

}

} catch (e) {

if (isVerbose) console.warn('[OMLS] Distill error: ' + (e.message || e));

}

}

if (schedule.should_explore) {

try {

const exploreResult = await tryExplore([], schedule, getRepoRoot());

if (exploreResult && exploreResult.signals && exploreResult.signals.length > 0) {

console.log('[OMLS] Explore discovered ' + exploreResult.signals.length + ' signals: ' + exploreResult.signals.slice(0, 5).join(', '));

}

} catch (e) {

if (isVerbose) console.warn('[OMLS] Explore error: ' + (e.message || e));

}

}

if (isVerbose && schedule.idle_seconds >= 0) {

console.log(`[OMLS] idle=${schedule.idle_seconds}s intensity=${schedule.intensity} multiplier=${omlsMultiplier}`);

}

}

} catch (e) {

if (isVerbose) console.warn('[OMLS] Scheduler error: ' + (e.message || e));

}

// Suicide check (memory leak protection). On Windows the

// in-process respawn opens a cmd popup (Issue #528), so by default

// we delegate to an external supervisor by exiting with a non-zero

// code instead. See spawnReplacementProcess() for the policy.

if (suicideEnabled) {

const memMb = process.memoryUsage().rss / 1024 / 1024;

if (cycleCount >= maxCyclesPerProcess || memMb > maxRssMb) {

console.log(`[Daemon] Restarting self (cycles=${cycleCount}, rssMb=${memMb.toFixed(0)})`);

const result = spawnReplacementProcess({

reason: 'max_cycles_or_rss',

args: args,

logPath: getEvolverLogPath(),

});

if (result.spawned) {

releaseLock();

process.exit(0);

} else if (result.reason === 'windows_default_skip') {

console.log('[Daemon] Exiting with code 1 to let external supervisor respawn.');

releaseLock();

process.exit(1);

} else {

// Non-Windows spawn error: keep the lock and fall through to

// the next iteration of the loop instead of leaving the daemon

// dead. This matches the pre-1.79.1 behavior where a failed

// spawn was logged and the process continued running.

console.error('[Daemon] Spawn failed, continuing current process.');

}

}

}

let saturationMultiplier = 1;

try {

const lastSignals = getLastSignals(solidifyStatePath);

if (lastSignals.includes('force_steady_state')) {

saturationMultiplier = 4;

console.log('[Daemon] Saturation detected. Entering steady-state mode (4x sleep).');

} else if (lastSignals.includes('evolution_saturation')) {

saturationMultiplier = 2;

console.log('[Daemon] Approaching saturation. Reducing evolution frequency (2x sleep).');

}

} catch (e) {

if (isVerbose) console.warn('[Daemon] Saturation check error: ' + (e.message || e));

}

// Jitter to avoid lockstep restarts.

const jitter = Math.floor(Math.random() * 250);

const totalSleepMs = Math.max(minSleepMs, (currentSleepMs + jitter) * saturationMultiplier * omlsMultiplier);

if (isVerbose) {

const memMb = (process.memoryUsage().rss / 1024 / 1024).toFixed(1);

const signals = getLastSignals(solidifyStatePath).join(',');

console.log(`[Verbose] cycle=${cycleCount} ok=${ok} dt=${dt}ms sleep=${totalSleepMs}ms (base=${currentSleepMs} jitter=${jitter} sat=${saturationMultiplier}x) rss=${memMb}MB signals=[${signals}]`);

}

writeCycleProgressAtomic(cycleProgressPath, {

pid: process.pid,

outer_cycle: cycleCount,

inner_cycle: cycleCount,

started_at: t0,

phase: 'sleep',

});

await sleepMs(totalSleepMs);

} catch (loopErr) {

console.error('[Daemon] Unexpected loop error (recovering): ' + (loopErr && loopErr.message ? loopErr.message : String(loopErr)));

await sleepMs(Math.max(minSleepMs, 10000));

}

}

} else {

// Normal Single Run

try {

await evolve.run();

} catch (error) {

console.error('Evolution failed:', error);

process.exit(1);

}

}

// Post-run hint

console.log('\n' + '=======================================================');

console.log('Evolver finished. If you use this project, consider starring the upstream repository.');

console.log('Upstream: https://github.com/EvoMap/evolver');

console.log('=======================================================\n');

} else if (command === 'solidify') {

const dryRun = args.includes('--dry-run');

const noRollback = args.includes('--no-rollback');

const intentFlag = args.find(a => typeof a === 'string' && a.startsWith('--intent='));

const summaryFlag = args.find(a => typeof a === 'string' && a.startsWith('--summary='));

const intent = intentFlag ? intentFlag.slice('--intent='.length) : null;

const summary = summaryFlag ? summaryFlag.slice('--summary='.length) : null;

try {

const res = await solidify({

intent: intent || undefined,

summary: summary || undefined,

dryRun,

rollbackOnFailure: !noRollback,

});

const st = res && res.ok ? 'SUCCESS' : 'FAILED';

console.log(`[SOLIDIFY] ${st}`);

if (res && res.gene) console.log(JSON.stringify(res.gene, null, 2));

if (res && res.event) console.log(JSON.stringify(res.event, null, 2));

if (res && res.capsule) console.log(JSON.stringify(res.capsule, null, 2));

if (res && res.ok && !dryRun) {

try {

const { shouldDistill, prepareDistillation, autoDistill, shouldDistillFromFailures, autoDistillFromFailures } = require('./src/gep/skillDistiller');

const { readStateForSolidify } = require('./src/gep/solidify');

const solidifyState = readStateForSolidify();

const count = solidifyState.solidify_count || 0;

const autoDistillInterval = 5;

const autoTrigger = count > 0 && count % autoDistillInterval === 0;

if (autoTrigger || shouldDistill()) {

const auto = autoDistill();

if (auto && auto.ok && auto.gene) {

console.log('[Distiller] Auto-distilled gene: ' + auto.gene.id);

} else {

const dr = prepareDistillation();

if (dr && dr.ok && dr.promptPath) {

const trigger = autoTrigger ? `auto (every ${autoDistillInterval} solidifies, count=${count})` : 'threshold';

console.log('\n[DISTILL_REQUEST]');

console.log(`Distillation triggered: ${trigger}`);

console.log('Read the prompt file, process it with your LLM,');

console.log('save the LLM response to a file, then run:');

console.log(' node index.js distill --response-file=<path_to_llm_response>');

console.log('Prompt file: ' + dr.promptPath);

console.log('[/DISTILL_REQUEST]');

}

}

}

if (shouldDistillFromFailures()) {

const failureResult = autoDistillFromFailures();

if (failureResult && failureResult.ok && failureResult.gene) {

console.log('[Distiller] Repair gene distilled from failures: ' + failureResult.gene.id);

}

}

} catch (e) {

console.warn('[Distiller] Init failed (non-fatal): ' + (e.message || e));

}

}

if (res && res.hubReviewPromise) {

await res.hubReviewPromise;

}

// Post-solidify urgent questions: when solidify fails or produces a

// low-quality outcome, generate questions and send them to Hub immediately.

if (!dryRun) {

try {

const { generateUrgentQuestions } = require('./src/gep/questionGenerator');

const { fetchTasks } = require('./src/gep/taskReceiver');

const urgentOpts = {};

if (!res || !res.ok) {

if (res && res.validation && !res.validation.ok) {

urgentOpts.validationFailed = true;

const failedStep = res.validation.results && res.validation.results.find(function (r) { return !r.ok; });

urgentOpts.validationErrors = failedStep ? (failedStep.err || failedStep.cmd || '') : '';

}

urgentOpts.geneId = res && res.gene ? res.gene.id : undefined;

const evtOutcome = res && res.event && res.event.outcome;

if (evtOutcome && typeof evtOutcome.score === 'number' && evtOutcome.score < 0.3) {

urgentOpts.lowConfidence = true;

urgentOpts.confidenceScore = evtOutcome.score;

urgentOpts.intent = res.event.intent;

}

if (res && res.blast && res.blast.files === 0 && res.blast.lines === 0) {

urgentOpts.zeroBlastRadius = true;

urgentOpts.hadSignals = true;

urgentOpts.signals = res.event && Array.isArray(res.event.signals) ? res.event.signals : [];

}

if (res && res.constraintCheck && Array.isArray(res.constraintCheck.violations)) {

const llmRejectV = res.constraintCheck.violations.find(function (v) { return String(v).startsWith('llm_review_rejected'); });

if (llmRejectV) {

urgentOpts.llmReviewRejected = true;

urgentOpts.llmReviewReason = String(llmRejectV).replace('llm_review_rejected: ', '');

}

}

const lr = readJsonSafe(path.join(require('./src/gep/paths').getEvolutionDir(), 'evolution_solidify_state.json'));

if (lr && lr.last_run && lr.last_run.active_task_id) {

urgentOpts.taskCompletionFailed = true;

urgentOpts.taskTitle = lr.last_run.active_task_title || '';

urgentOpts.taskSignals = Array.isArray(lr.last_run.task_signals) ? lr.last_run.task_signals.join(', ') : '';

}

} else if (res.event && res.event.outcome && res.event.outcome.score < 0.3) {

urgentOpts.lowConfidence = true;

urgentOpts.confidenceScore = res.event.outcome.score;

urgentOpts.intent = res.event.intent;

}

if (Object.keys(urgentOpts).length > 0) {

const urgentQs = generateUrgentQuestions(urgentOpts);

if (urgentQs.length > 0) {

console.log('[UrgentQ] Generated ' + urgentQs.length + ' urgent question(s) from solidify outcome.');

try {

const fetchRes = await fetchTasks({ questions: urgentQs });

if (fetchRes.questions_created) {

const accepted = fetchRes.questions_created.filter(function (q) { return !q.error; });

if (accepted.length > 0) {

console.log('[UrgentQ] Hub accepted ' + accepted.length + ' urgent question(s) as bounties.');

}

}

} catch (err) {

console.log('[UrgentQ] Send failed (non-fatal): ' + (err && err.message ? err.message : err));

}

}

}

} catch (e) {

console.log('[UrgentQ] Init failed (non-fatal): ' + (e && e.message ? e.message : e));

}

}

process.exit(res && res.ok ? 0 : 2);

} catch (error) {

console.error('[SOLIDIFY] Error:', error);

process.exit(2);

}

} else if (command === 'distill') {

const responseFileFlag = args.find(a => typeof a === 'string' && a.startsWith('--response-file='));

if (!responseFileFlag) {

console.error('Usage: node index.js distill --response-file=<path>');

process.exit(1);

}

const responseFilePath = responseFileFlag.slice('--response-file='.length);

{

const { getRepoRoot } = require('./src/gep/paths');

const resolvedResponsePath = path.resolve(responseFilePath);

const resolvedRepoRoot = path.resolve(getRepoRoot());

if (responseFilePath.includes('..') || !resolvedResponsePath.startsWith(resolvedRepoRoot)) {

console.error('[Distill] ERROR: Invalid response-file path "' + responseFilePath + '" - path traversal detected or path is outside the repository.');

process.exit(2);

}

}

try {

const responseText = fs.readFileSync(responseFilePath, 'utf8');

const { completeDistillation } = require('./src/gep/skillDistiller');

const result = completeDistillation(responseText);

if (result && result.ok) {

console.log('[Distiller] Gene produced: ' + result.gene.id);

console.log(JSON.stringify(result.gene, null, 2));

} else {

console.warn('[Distiller] Distillation did not produce a gene: ' + (result && result.reason || 'unknown'));

}

process.exit(result && result.ok ? 0 : 2);

} catch (error) {

console.error('[DISTILL] Error:', error);

process.exit(2);

}

} else if (command === 'review' || command === '--review') {

const { getEvolutionDir, getRepoRoot } = require('./src/gep/paths');

const { loadGenes } = require('./src/gep/assetStore');

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

const MAX_EXEC_BUFFER = 10 * 1024 * 1024; // 10MB; see GHSA reports / #451

const statePath = path.join(getEvolutionDir(), 'evolution_solidify_state.json');

const state = readJsonSafe(statePath);

const lastRun = state && state.last_run ? state.last_run : null;

if (!lastRun || !lastRun.run_id) {

console.log('[Review] No pending evolution run to review.');

console.log('Run "node index.js run" first to produce changes, then review before solidifying.');

process.exit(0);

}

const lastSolid = state && state.last_solidify ? state.last_solidify : null;

if (lastSolid && String(lastSolid.run_id) === String(lastRun.run_id)) {

console.log('[Review] Last run has already been solidified. Nothing to review.');

process.exit(0);

}

const repoRoot = getRepoRoot();

let diff = '';

try {

const unstaged = execSync('git diff', { cwd: repoRoot, encoding: 'utf8', timeout: 30000, maxBuffer: MAX_EXEC_BUFFER }).trim();

const staged = execSync('git diff --cached', { cwd: repoRoot, encoding: 'utf8', timeout: 30000, maxBuffer: MAX_EXEC_BUFFER }).trim();

const untracked = execSync('git ls-files --others --exclude-standard', { cwd: repoRoot, encoding: 'utf8', timeout: 10000, maxBuffer: MAX_EXEC_BUFFER }).trim();

if (staged) diff += '=== Staged Changes ===\n' + staged + '\n\n';

if (unstaged) diff += '=== Unstaged Changes ===\n' + unstaged + '\n\n';

if (untracked) diff += '=== Untracked Files ===\n' + untracked + '\n';

} catch (e) {

diff = '(failed to capture diff: ' + (e.message || e) + ')';

}

const genes = loadGenes();

const geneId = lastRun.selected_gene_id ? String(lastRun.selected_gene_id) : null;

const gene = geneId ? genes.find(g => g && g.type === 'Gene' && g.id === geneId) : null;

const signals = Array.isArray(lastRun.signals) ? lastRun.signals : [];

const mutation = lastRun.mutation || null;

console.log('\n' + '='.repeat(60));

console.log('[Review] Pending evolution run: ' + lastRun.run_id);

console.log('='.repeat(60));

console.log('\n--- Gene ---');

if (gene) {

console.log(' ID: ' + gene.id);

console.log(' Category: ' + (gene.category || '?'));

console.log(' Summary: ' + (gene.summary || '?'));

if (Array.isArray(gene.strategy) && gene.strategy.length > 0) {

console.log(' Strategy:');

gene.strategy.forEach((s, i) => console.log(' ' + (i + 1) + '. ' + s));

}

} else {

console.log(' (no gene selected or gene not found: ' + (geneId || 'none') + ')');

}

console.log('\n--- Signals ---');

if (signals.length > 0) {

signals.forEach(s => console.log(' - ' + s));

} else {

console.log(' (no signals)');

}

console.log('\n--- Mutation ---');

if (mutation) {

console.log(' Category: ' + (mutation.category || '?'));

console.log(' Risk Level: ' + (mutation.risk_level || '?'));

if (mutation.rationale) console.log(' Rationale: ' + mutation.rationale);

} else {

console.log(' (no mutation data)');

}

if (lastRun.blast_radius_estimate) {

console.log('\n--- Blast Radius Estimate ---');

const br = lastRun.blast_radius_estimate;

console.log(' Files changed: ' + (br.files_changed || '?'));

console.log(' Lines changed: ' + (br.lines_changed || '?'));

}

console.log('\n--- Diff ---');

if (diff.trim()) {

console.log(diff.length > 5000 ? diff.slice(0, 5000) + '\n... (truncated, ' + diff.length + ' chars total)' : diff);

} else {

console.log(' (no changes detected)');

}

console.log('='.repeat(60));

if (args.includes('--approve')) {

console.log('\n[Review] Approved. Running solidify...\n');

try {

const res = await solidify({

intent: lastRun.intent || undefined,

rollbackOnFailure: true,

});

const st = res && res.ok ? 'SUCCESS' : 'FAILED';

console.log(`[SOLIDIFY] ${st}`);

if (res && res.gene) console.log(JSON.stringify(res.gene, null, 2));

if (res && res.hubReviewPromise) {

await res.hubReviewPromise;

}

process.exit(res && res.ok ? 0 : 2);

} catch (error) {

console.error('[SOLIDIFY] Error:', error);

process.exit(2);

}

} else if (args.includes('--reject')) {

console.log('\n[Review] Rejected. Rolling back changes...');