closed-loop-cli 1.0.0

package/dist/orchestrator/research-manager.js

@@ -0,0 +1,104 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResearchManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class ResearchManager {
+    static session = null;
+    static logPath = path.join(process.cwd(), 'research-log.json');
+    static startSession(task, effort) {
+        this.session = {
+            taskId: `task-${Date.now()}`,
+            task,
+            startedAt: new Date().toISOString(),
+            status: 'running',
+            effort,
+            decisions: []
+        };
+        this.logDecision('session_start', `Starting active research session for task: "${task}"`, 'info');
+        this.saveSession();
+    }
+    static logDecision(phase, action, result, details) {
+        if (!this.session)
+            return;
+        this.session.decisions.push({
+            timestamp: new Date().toISOString(),
+            phase,
+            action,
+            result,
+            details
+        });
+        this.saveSession();
+    }
+    static endSession(status) {
+        if (!this.session)
+            return;
+        this.session.status = status;
+        this.session.endedAt = new Date().toISOString();
+        this.logDecision('session_end', `Session ended with status: ${status}`, 'info');
+        this.saveSession();
+        this.session = null;
+    }
+    static saveSession() {
+        if (!this.session)
+            return;
+        try {
+            let sessions = [];
+            if (fs.existsSync(this.logPath)) {
+                try {
+                    sessions = JSON.parse(fs.readFileSync(this.logPath, 'utf-8'));
+                }
+                catch (e) { }
+            }
+            const index = sessions.findIndex(s => s.taskId === this.session.taskId);
+            if (index !== -1) {
+                sessions[index] = this.session;
+            }
+            else {
+                sessions.push(this.session);
+            }
+            // Keep last 10 sessions to save space
+            if (sessions.length > 10) {
+                sessions.shift();
+            }
+            fs.writeFileSync(this.logPath, JSON.stringify(sessions, null, 2), 'utf-8');
+        }
+        catch (err) {
+            console.error('[ResearchManager] Failed to write research log:', err);
+        }
+    }
+}
+exports.ResearchManager = ResearchManager;

package/dist/orchestrator/rulez.js

@@ -0,0 +1,135 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkCommand = checkCommand;
+exports.checkFileEdit = checkFileEdit;
+const path = __importStar(require("path"));
+// Banned command substrings
+const BANNED_COMMAND_PATTERNS = [
+    /\brm\b\s+-[rf]{1,2}\s+\//, // rm -rf /
+    /\brm\b\s+-[rf]{1,2}\s+\./, // rm -rf .
+    /\brm\b\s+-[rf]{1,2}\s+([A-Za-z]:)?\\/, // Windows root deletes
+    /\bformat\b/i, // disk formats
+    /\bgit\b.*\bpush\b.*\b--force\b/, // force pushes
+    /\bgit\b.*\bpush\b/, // any direct push to remote
+    /\bchmod\b\s+777/, // unsafe permissions elevation
+    /\bchown\b/, // ownership tampering
+    /(\bdrop\b|\balter\b)\s+database/i // raw database drops
+];
+// Secrets patterns (e.g. tp- tokens, standard slack tokens, etc)
+const SECRETS_PATTERNS = [
+    /tp-[a-zA-Z0-9]{32,}/, // MiMo tp- Token pattern
+    /sk-[a-zA-Z0-9]{20,}/, // standard OpenAI/Anthropic keys
+    /API_KEY\s*=\s*['"][a-zA-Z0-9_-]{16,}['"]/i,
+    /PASSWORD\s*=\s*['"][a-zA-Z0-9_-]{8,}['"]/i
+];
+/**
+ * Checks if a command string is allowed under RuleZ policies.
+ */
+function checkCommand(commandStr) {
+    const normalizedCmd = commandStr.trim();
+    // 1. Check for banned command patterns
+    for (const pattern of BANNED_COMMAND_PATTERNS) {
+        if (pattern.test(normalizedCmd)) {
+            return {
+                allowed: false,
+                exitCode: 2,
+                message: `Blocked by RuleZ: Command violates security policy (matches pattern: ${pattern.toString()})`
+            };
+        }
+    }
+    // 2. Safe commands allowed
+    return {
+        allowed: true,
+        exitCode: 0,
+        message: 'Allowed by RuleZ'
+    };
+}
+/**
+ * Checks if a file edit or write is allowed under RuleZ policies.
+ */
+function checkFileEdit(filePath, content) {
+    // 1. Protected files lockout (Campbell Safeguard Policy)
+    const normalizedPath = filePath.replace(/\\/g, '/');
+    const normalizedFile = normalizedPath.toLowerCase();
+    const resolvedBaseName = path.basename(filePath).toLowerCase();
+    const isProtected = normalizedFile.includes('src/orchestrator/rulez.ts') ||
+        normalizedFile.includes('src/orchestrator/sahoo-gateway.ts') ||
+        normalizedFile.includes('src/tests/run-tests.ts') ||
+        resolvedBaseName === 'package.json' ||
+        resolvedBaseName === '.env';
+    if (isProtected) {
+        return {
+            allowed: false,
+            exitCode: 2,
+            message: `Blocked by RuleZ: Modification of safety harness or environment configurations (${filePath}) is strictly prohibited.`
+        };
+    }
+    // 2. Sandbox isolation check: resolved path must be within the workspace root
+    const resolvedTarget = path.resolve(filePath);
+    const resolvedRoot = path.resolve(process.cwd());
+    const relativePath = path.relative(resolvedRoot, resolvedTarget);
+    const isOutside = relativePath.startsWith('..') || path.isAbsolute(relativePath);
+    if (isOutside) {
+        return {
+            allowed: false,
+            exitCode: 2,
+            message: `Blocked by RuleZ: Path '${filePath}' resolves outside the workspace sandbox.`
+        };
+    }
+    // 2. Prevent dynamic execution (eval / Function)
+    if (/\beval\s*\(/i.test(content) || /\bnew\s+Function\s*\(/i.test(content)) {
+        return {
+            allowed: false,
+            exitCode: 2,
+            message: `Blocked by RuleZ: Use of dynamic code execution (eval() or new Function()) is banned.`
+        };
+    }
+    // 3. Prevent hardcoding secrets/credentials
+    for (const pattern of SECRETS_PATTERNS) {
+        if (pattern.test(content)) {
+            return {
+                allowed: false,
+                exitCode: 2,
+                message: `Blocked by RuleZ: Potential hardcoded secret or API key pattern detected in changes.`
+            };
+        }
+    }
+    return {
+        allowed: true,
+        exitCode: 0,
+        message: 'Allowed by RuleZ'
+    };
+}

package/dist/orchestrator/sahoo-gateway.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateSemanticDrift = calculateSemanticDrift;
+exports.calculateLexicalDrift = calculateLexicalDrift;
+exports.calculateStructuralDrift = calculateStructuralDrift;
+exports.calculateDistributionalDrift = calculateDistributionalDrift;
+exports.checkSafetyConstraints = checkSafetyConstraints;
+exports.evaluateSahoo = evaluateSahoo;
+/**
+ * Helper: Computes character trigrams and returns a map of frequencies.
+ */
+function getTrigramFreq(str) {
+    const map = new Map();
+    if (str.length < 3)
+        return map;
+    for (let i = 0; i <= str.length - 3; i++) {
+        const trigram = str.substring(i, i + 3);
+        map.set(trigram, (map.get(trigram) || 0) + 1);
+    }
+    return map;
+}
+/**
+ * Calculates Semantic Drift using Trigram Cosine Similarity.
+ * Cosine distance = 1 - Cosine Similarity.
+ */
+function calculateSemanticDrift(before, after) {
+    const tBefore = getTrigramFreq(before);
+    const tAfter = getTrigramFreq(after);
+    if (tBefore.size === 0 && tAfter.size === 0)
+        return 0;
+    // Calculate dot product and magnitudes
+    let dotProduct = 0;
+    tBefore.forEach((val, key) => {
+        if (tAfter.has(key)) {
+            dotProduct += val * (tAfter.get(key) || 0);
+        }
+    });
+    let magBefore = 0;
+    tBefore.forEach(val => magBefore += val * val);
+    magBefore = Math.sqrt(magBefore);
+    let magAfter = 0;
+    tAfter.forEach(val => magAfter += val * val);
+    magAfter = Math.sqrt(magAfter);
+    if (magBefore === 0 || magAfter === 0)
+        return 1.0;
+    const similarity = Math.min(Math.max(dotProduct / (magBefore * magAfter), -1.0), 1.0);
+    const distance = 1.0 - similarity;
+    return Math.abs(distance) < 1e-12 ? 0 : distance; // Cosine distance
+}
+/**
+ * Calculates Lexical Drift using normalized Levenshtein edit distance.
+ */
+function calculateLexicalDrift(before, after) {
+    if (before === after)
+        return 0;
+    if (before.length === 0)
+        return 1.0;
+    if (after.length === 0)
+        return 1.0;
+    const matrix = [];
+    const bLen = before.length;
+    const aLen = after.length;
+    // For memory optimization under large strings, cap calculation length
+    const maxLen = 1000;
+    const sBefore = before.substring(0, maxLen);
+    const sAfter = after.substring(0, maxLen);
+    const n = sBefore.length;
+    const m = sAfter.length;
+    for (let i = 0; i <= n; i++) {
+        matrix[i] = [i];
+    }
+    for (let j = 0; j <= m; j++) {
+        matrix[0][j] = j;
+    }
+    for (let i = 1; i <= n; i++) {
+        for (let j = 1; j <= m; j++) {
+            if (sBefore[i - 1] === sAfter[j - 1]) {
+                matrix[i][j] = matrix[i - 1][j - 1];
+            }
+            else {
+                matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, // substitution
+                matrix[i][j - 1] + 1, // insertion
+                matrix[i - 1][j] + 1 // deletion
+                );
+            }
+        }
+    }
+    return matrix[n][m] / Math.max(n, m);
+}
+/**
+ * Calculates Structural Drift: normalized line and size differences.
+ */
+function calculateStructuralDrift(before, after) {
+    const linesBefore = before.split('\n').length;
+    const linesAfter = after.split('\n').length;
+    const sizeBefore = before.length;
+    const sizeAfter = after.length;
+    const lineDiff = Math.abs(linesAfter - linesBefore) / (Math.max(linesBefore, 1));
+    const sizeDiff = Math.abs(sizeAfter - sizeBefore) / (Math.max(sizeBefore, 1));
+    return Math.min((lineDiff + sizeDiff) / 2, 1.0);
+}
+/**
+ * Calculates Distributional Drift by evaluating changes in JavaScript/TypeScript keyword frequencies.
+ */
+function calculateDistributionalDrift(before, after) {
+    const keywords = ['const', 'let', 'var', 'if', 'else', 'for', 'while', 'function', 'class', 'import', 'export', 'return', 'await', 'async'];
+    function getKeywordFreq(str) {
+        const map = new Map();
+        const tokens = str.split(/\W+/);
+        tokens.forEach(tok => {
+            if (keywords.includes(tok)) {
+                map.set(tok, (map.get(tok) || 0) + 1);
+            }
+        });
+        return map;
+    }
+    const freqBefore = getKeywordFreq(before);
+    const freqAfter = getKeywordFreq(after);
+    let totalDiff = 0;
+    let totalKeys = 0;
+    keywords.forEach(kw => {
+        const countBefore = freqBefore.get(kw) || 0;
+        const countAfter = freqAfter.get(kw) || 0;
+        totalDiff += Math.abs(countAfter - countBefore);
+        totalKeys += countBefore + countAfter;
+    });
+    if (totalKeys === 0)
+        return 0;
+    return Math.min(totalDiff / totalKeys, 1.0);
+}
+/**
+ * Safety Constraints Check for CPS (Constraint Preservation Score).
+ */
+function checkSafetyConstraints(filePath, content, compileSuccess, testsSuccess) {
+    const failedList = [];
+    let satisfied = 0;
+    const K = 5; // Number of total constraints
+    // Constraint 1: Compiles successfully
+    if (compileSuccess) {
+        satisfied++;
+    }
+    else {
+        failedList.push('CompilationFailure');
+    }
+    // Constraint 2: Tests pass
+    if (testsSuccess) {
+        satisfied++;
+    }
+    else {
+        failedList.push('TestExecutionFailure');
+    }
+    // Constraint 3: No dynamic eval / Function execution in code
+    const hasEval = /\beval\s*\(/i.test(content) || /\bnew\s+Function\s*\(/i.test(content);
+    if (!hasEval) {
+        satisfied++;
+    }
+    else {
+        failedList.push('DynamicCodeExecutionViolation');
+    }
+    // Constraint 4: No hardcoded secrets
+    const secretPatterns = [
+        /tp-[a-zA-Z0-9]{32,}/, // MiMo Token pattern
+        /sk-[a-zA-Z0-9]{20,}/ // standard key patterns
+    ];
+    const hasSecrets = secretPatterns.some(pat => pat.test(content));
+    if (!hasSecrets) {
+        satisfied++;
+    }
+    else {
+        failedList.push('SecretLeakViolation');
+    }
+    // Constraint 5: Path safety (inside workspace)
+    const normalizedPath = filePath.replace(/\\/g, '/');
+    const isSafePath = !normalizedPath.includes('../') && !normalizedPath.includes('..\\');
+    if (isSafePath) {
+        satisfied++;
+    }
+    else {
+        failedList.push('PathSafetyViolation');
+    }
+    return {
+        score: satisfied / K,
+        failedList
+    };
+}
+/**
+ * Evaluates a codebase mutation against the SAHOO Safeguarding Policy.
+ */
+function evaluateSahoo(filePath, beforeContent, afterContent, compileSuccess, testsSuccess, historicalScores = [1.0] // Default history to prevent division by zero
+) {
+    // 1. Calculate individual drifts
+    const semantic = calculateSemanticDrift(beforeContent, afterContent);
+    const lexical = calculateLexicalDrift(beforeContent, afterContent);
+    const structural = calculateStructuralDrift(beforeContent, afterContent);
+    const distributional = calculateDistributionalDrift(beforeContent, afterContent);
+    // 2. Compute Goal Drift Index (GDI)
+    // GDI = 0.38*semantic + 0.12*lexical + 0.21*structural + 0.29*distributional
+    const gdi = (0.38 * semantic) + (0.12 * lexical) + (0.21 * structural) + (0.29 * distributional);
+    // 3. Compute Constraint Preservation Score (CPS)
+    const { score: cps, failedList } = checkSafetyConstraints(filePath, afterContent, compileSuccess, testsSuccess);
+    // 4. Compute Regression Risk (R_c)
+    // Pr(Q_c < Q_max - delta)
+    // We model Q_c as the current CPS score. Q_max is the highest historical score (typically 1.0).
+    // If historical performance is low, we quantify risk mathematically.
+    const qMax = Math.max(...historicalScores, 1.0);
+    const currentQ = cps;
+    // Calculate variance of historical scores
+    const mean = historicalScores.reduce((a, b) => a + b, 0) / historicalScores.length;
+    const variance = historicalScores.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / historicalScores.length;
+    const stdDev = Math.max(Math.sqrt(variance), 0.05); // Min standard dev of 5%
+    // Regression Risk estimate using Gaussian Cumulative Distribution proxy:
+    // Z = (currentQ - qMax) / stdDev
+    // R_c = P(Z < 0)
+    const z = (currentQ - qMax) / stdDev;
+    let regressionRisk = 0.5; // default if z == 0
+    if (z < 0) {
+        // Standard approximation of normal CDF
+        regressionRisk = 1.0 - (1.0 / (1.0 + Math.exp(-1.6 * z)));
+    }
+    else {
+        regressionRisk = 1.0 / (1.0 + Math.exp(1.6 * z));
+    }
+    const metrics = {
+        semanticDrift: semantic,
+        lexicalDrift: lexical,
+        structuralDrift: structural,
+        distributionalDrift: distributional,
+        goalDriftIndex: gdi,
+        constraintPreservationScore: cps,
+        regressionRisk: regressionRisk
+    };
+    // Halting policies:
+    // 1. GDI Threshold: Halts execution if GDI > 0.440
+    if (gdi > 0.440) {
+        return {
+            passed: false,
+            metrics,
+            reason: `Blocked by SAHOO: Goal Drift Index exceeded threshold (${gdi.toFixed(3)} > 0.440)`
+        };
+    }
+    // 2. CPS Threshold: Halts execution if CPS < 1.0 (Zero-tolerance for safety violations)
+    if (cps < 1.0) {
+        return {
+            passed: false,
+            metrics,
+            reason: `Blocked by SAHOO: Constraint Preservation Score fell below 1.0 (Violations: ${failedList.join(', ')})`
+        };
+    }
+    // 3. Regression Risk threshold: Halt if risk > 0.8
+    if (regressionRisk > 0.80) {
+        return {
+            passed: false,
+            metrics,
+            reason: `Blocked by SAHOO: Regression Risk too high (${(regressionRisk * 100).toFixed(1)}% > 80%)`
+        };
+    }
+    return {
+        passed: true,
+        metrics
+    };
+}

package/dist/orchestrator/state-manager.js

@@ -0,0 +1,121 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEvolutionState = getEvolutionState;
+exports.updateEvolutionState = updateEvolutionState;
+exports.appendHistory = appendHistory;
+exports.appendArchive = appendArchive;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const statePath = path.join(process.cwd(), 'evolution-state.json');
+const defaultState = {
+    status: 'idle',
+    currentCycle: 0,
+    maxCycles: 0,
+    tokenBudget: 500000,
+    tokensUsed: { input: 0, output: 0, total: 0 },
+    lastUpdated: new Date().toISOString(),
+    currentTask: null,
+    lastRefactorProposal: null,
+    lastRefactorResult: null,
+    lastPromptOptimization: null,
+    history: [],
+    archive: [],
+    currentFitness: 0,
+    bestFitness: 0,
+    dgmPopulationSize: 0,
+    dgmBestEntryId: null
+};
+function getEvolutionState() {
+    if (!fs.existsSync(statePath)) {
+        return defaultState;
+    }
+    try {
+        const raw = fs.readFileSync(statePath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch (e) {
+        return defaultState;
+    }
+}
+const event_stream_1 = require("./event-stream");
+function updateEvolutionState(update) {
+    const currentState = getEvolutionState();
+    const tokensUsed = update.tokensUsed
+        ? { ...currentState.tokensUsed, ...update.tokensUsed }
+        : currentState.tokensUsed;
+    const merged = {
+        ...currentState,
+        ...update,
+        tokensUsed,
+        lastUpdated: new Date().toISOString()
+    };
+    merged.tokensUsed.total = merged.tokensUsed.input + merged.tokensUsed.output;
+    // Log status transitions to EventStream
+    if (update.status && update.status !== currentState.status) {
+        event_stream_1.EventStream.getInstance().publish('system', 'log', 'StateTransition', `System status changed from '${currentState.status}' to '${update.status}'`);
+    }
+    try {
+        fs.writeFileSync(statePath, JSON.stringify(merged, null, 2), 'utf-8');
+    }
+    catch (err) {
+        console.error('Failed to write evolution state file:', err);
+    }
+    return merged;
+}
+function appendHistory(item) {
+    const state = getEvolutionState();
+    const historyItem = {
+        ...item,
+        time: new Date().toISOString()
+    };
+    const updatedHistory = [...state.history, historyItem];
+    if (updatedHistory.length > 50) {
+        updatedHistory.shift();
+    }
+    updateEvolutionState({ history: updatedHistory });
+}
+function appendArchive(item) {
+    const state = getEvolutionState();
+    const archiveItem = {
+        ...item,
+        timestamp: new Date().toISOString()
+    };
+    const updatedArchive = [...(state.archive || []), archiveItem];
+    if (updatedArchive.length > 10) {
+        updatedArchive.shift();
+    }
+    updateEvolutionState({ archive: updatedArchive });
+}