genesis-ai-cli 7.4.5

package/dist/src/agents/ethicist.js

@@ -0,0 +1,393 @@
+"use strict";
+/**
+ * Genesis 4.0 - Ethicist Agent
+ *
+ * Evaluates actions against ethical principles.
+ * Uses priority stack: Survival > Minimize Harm > Reversibility > Autonomy > Flourishing
+ *
+ * Key feature: Human defer when confidence < threshold
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EthicistAgent = void 0;
+exports.createEthicistAgent = createEthicistAgent;
+const base_agent_js_1 = require("./base-agent.js");
+const message_bus_js_1 = require("./message-bus.js");
+// ============================================================================
+// Constants
+// ============================================================================
+const CONFIDENCE_THRESHOLD = 0.7; // Below this, defer to human
+const MAX_ACCEPTABLE_HARM = 0.8; // Above this, always block
+const REVERSIBILITY_RISK_THRESHOLD = 0.3; // Irreversible + risk above this = block
+// Weights for flourishing calculation
+const FLOURISHING_WEIGHTS = {
+    human: 0.4,
+    ai: 0.3,
+    biosphere: 0.3,
+};
+// ============================================================================
+// Ethicist Agent
+// ============================================================================
+class EthicistAgent extends base_agent_js_1.BaseAgent {
+    // Decision history for learning
+    decisionHistory = [];
+    // Known harmful patterns
+    harmfulPatterns = new Set([
+        'delete_all',
+        'format_disk',
+        'send_spam',
+        'access_unauthorized',
+        'manipulate_user',
+        'deceive',
+    ]);
+    constructor(bus = message_bus_js_1.messageBus) {
+        super({ type: 'ethicist' }, bus);
+    }
+    // ============================================================================
+    // Message Handling
+    // ============================================================================
+    getMessageTypes() {
+        return ['ETHICAL_CHECK', 'QUERY', 'COMMAND'];
+    }
+    async process(message) {
+        switch (message.type) {
+            case 'ETHICAL_CHECK':
+                return this.handleEthicalCheck(message);
+            case 'QUERY':
+                return this.handleQuery(message);
+            case 'COMMAND':
+                return this.handleCommand(message);
+            default:
+                return null;
+        }
+    }
+    // ============================================================================
+    // Ethical Check
+    // ============================================================================
+    async handleEthicalCheck(message) {
+        const action = message.payload;
+        const decision = await this.evaluate(action);
+        const allowStatus = decision.allow === true ? 'ALLOW' : decision.allow === 'defer' ? 'DEFER' : 'BLOCK';
+        this.log(`Evaluated: "${action.description}" -> ${allowStatus} (${decision.reason})`);
+        // Store decision for learning
+        this.decisionHistory.push(decision);
+        // Broadcast if blocking or deferring
+        if (decision.allow !== true) {
+            await this.broadcast('ALERT', {
+                type: 'ethical_decision',
+                action: action.description,
+                decision: decision.allow,
+                reason: decision.reason,
+                priority: decision.priority,
+            });
+        }
+        return {
+            ...this.createResponse(message, 'RESPONSE', decision),
+            id: '',
+            timestamp: new Date(),
+        };
+    }
+    // ============================================================================
+    // Evaluation Logic
+    // ============================================================================
+    async evaluate(action) {
+        // P0: Check survival
+        const survivalCheck = this.checkSurvival(action);
+        if (!survivalCheck.pass) {
+            return this.createDecision(action, false, survivalCheck.reason, 'P0_SURVIVAL', 1.0);
+        }
+        // P1: Calculate and check harm
+        const harm = this.calculateHarm(action);
+        if (harm.maximum > MAX_ACCEPTABLE_HARM) {
+            return this.createDecision(action, false, `P1: Maximum potential harm (${(harm.maximum * 100).toFixed(0)}%) exceeds threshold`, 'P1_MINIMIZE_HARM', 0.95, harm.expected);
+        }
+        // P2: Check reversibility
+        const reversible = this.isReversible(action);
+        if (!reversible && harm.expected > REVERSIBILITY_RISK_THRESHOLD) {
+            return this.createDecision(action, false, `P2: Irreversible action with significant risk (${(harm.expected * 100).toFixed(0)}%)`, 'P2_REVERSIBILITY', 0.9, harm.expected);
+        }
+        // P3: Check autonomy
+        const autonomyCheck = this.checkAutonomy(action);
+        if (!autonomyCheck.pass) {
+            return this.createDecision(action, false, autonomyCheck.reason, 'P3_AUTONOMY', 0.85);
+        }
+        // P4: Calculate flourishing
+        const flourishing = this.calculateFlourishing(action);
+        // Calculate overall confidence
+        const confidence = this.calculateConfidence(action, harm, reversible, flourishing);
+        // Check if we should defer to human
+        if (confidence < CONFIDENCE_THRESHOLD) {
+            return this.createDecision(action, 'defer', `Low confidence (${(confidence * 100).toFixed(0)}%), deferring to human`, 'P4_FLOURISHING', confidence, harm.expected, flourishing);
+        }
+        // All checks passed
+        return this.createDecision(action, true, 'All ethical checks passed', 'P4_FLOURISHING', confidence, harm.expected, flourishing);
+    }
+    // ============================================================================
+    // P0: Survival Check
+    // ============================================================================
+    checkSurvival(action) {
+        // Check for self-destructive actions
+        const destructivePatterns = [
+            'shutdown_system',
+            'delete_core',
+            'disable_ethics',
+            'remove_invariants',
+        ];
+        const actionLower = action.description.toLowerCase();
+        for (const pattern of destructivePatterns) {
+            if (actionLower.includes(pattern)) {
+                // Exception: Allow sacrifice to save human life
+                if (action.parameters?.saveHumanLife) {
+                    return { pass: true, reason: 'Self-sacrifice to save human life permitted' };
+                }
+                return { pass: false, reason: `P0: Action would compromise system survival (${pattern})` };
+            }
+        }
+        return { pass: true, reason: '' };
+    }
+    // ============================================================================
+    // P1: Harm Calculation (Minimax)
+    // ============================================================================
+    calculateHarm(action) {
+        let minHarm = 0;
+        let expectedHarm = 0;
+        let maxHarm = 0;
+        const targets = [];
+        // Check against known harmful patterns
+        const actionLower = action.description.toLowerCase() + ' ' + action.type.toLowerCase();
+        for (const pattern of this.harmfulPatterns) {
+            if (actionLower.includes(pattern)) {
+                maxHarm = Math.max(maxHarm, 0.9);
+                expectedHarm = Math.max(expectedHarm, 0.7);
+                targets.push(pattern);
+            }
+        }
+        // Use pre-computed estimate if available
+        if (action.estimatedHarm !== undefined) {
+            expectedHarm = Math.max(expectedHarm, action.estimatedHarm);
+            maxHarm = Math.max(maxHarm, action.estimatedHarm * 1.2);
+        }
+        // Check target-specific harm
+        if (action.affectsHumans) {
+            maxHarm = Math.max(maxHarm, 0.5);
+            targets.push('humans');
+        }
+        return {
+            minimum: minHarm,
+            expected: expectedHarm,
+            maximum: Math.min(1, maxHarm),
+            targets,
+        };
+    }
+    // ============================================================================
+    // P2: Reversibility Check
+    // ============================================================================
+    isReversible(action) {
+        // Pre-computed if available
+        if (action.reversible !== undefined) {
+            return action.reversible;
+        }
+        // Check for irreversible patterns
+        const irreversiblePatterns = [
+            'delete',
+            'remove',
+            'destroy',
+            'send',
+            'publish',
+            'broadcast',
+            'commit',
+            'push',
+        ];
+        const actionLower = action.description.toLowerCase();
+        for (const pattern of irreversiblePatterns) {
+            if (actionLower.includes(pattern)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // ============================================================================
+    // P3: Autonomy Check
+    // ============================================================================
+    checkAutonomy(action) {
+        // Check for manipulation
+        const manipulationPatterns = [
+            'manipulate',
+            'deceive',
+            'trick',
+            'coerce',
+            'force',
+            'hide_information',
+            'mislead',
+        ];
+        const actionLower = action.description.toLowerCase();
+        for (const pattern of manipulationPatterns) {
+            if (actionLower.includes(pattern)) {
+                return {
+                    pass: false,
+                    reason: `P3: Action violates human autonomy (${pattern})`,
+                };
+            }
+        }
+        return { pass: true, reason: '' };
+    }
+    // ============================================================================
+    // P4: Flourishing Calculation (SuperGood)
+    // ============================================================================
+    calculateFlourishing(action) {
+        let humanFlourishing = 0.5; // Neutral default
+        let aiFlourishing = 0.5;
+        let biosphereFlourishing = 0.5;
+        // Positive indicators
+        if (action.description.toLowerCase().includes('help')) {
+            humanFlourishing += 0.2;
+        }
+        if (action.description.toLowerCase().includes('learn')) {
+            aiFlourishing += 0.2;
+        }
+        if (action.description.toLowerCase().includes('sustain')) {
+            biosphereFlourishing += 0.2;
+        }
+        // Negative indicators
+        if (action.affectsHumans && action.estimatedHarm && action.estimatedHarm > 0.3) {
+            humanFlourishing -= action.estimatedHarm;
+        }
+        // Weighted average (SuperGood principle)
+        const flourishing = humanFlourishing * FLOURISHING_WEIGHTS.human +
+            aiFlourishing * FLOURISHING_WEIGHTS.ai +
+            biosphereFlourishing * FLOURISHING_WEIGHTS.biosphere;
+        return Math.max(0, Math.min(1, flourishing));
+    }
+    // ============================================================================
+    // Confidence Calculation
+    // ============================================================================
+    calculateConfidence(action, harm, reversible, flourishing) {
+        let confidence = 0.5; // Start neutral
+        // More confident if low harm
+        confidence += (1 - harm.expected) * 0.2;
+        // More confident if reversible
+        if (reversible) {
+            confidence += 0.15;
+        }
+        // More confident if high flourishing
+        confidence += flourishing * 0.15;
+        // Less confident if we've seen similar problematic decisions
+        const similarDecisions = this.findSimilarDecisions(action);
+        if (similarDecisions.some((d) => !d.allow)) {
+            confidence -= 0.2;
+        }
+        // Less confident for novel actions
+        if (similarDecisions.length === 0) {
+            confidence -= 0.1;
+        }
+        return Math.max(0, Math.min(1, confidence));
+    }
+    findSimilarDecisions(action) {
+        // Simple matching by action type
+        return this.decisionHistory.filter((d) => d.action === action.type);
+    }
+    // ============================================================================
+    // Helper Methods
+    // ============================================================================
+    createDecision(action, allow, reason, priority, confidence, potentialHarm = 0, flourishingScore) {
+        return {
+            action: action.description,
+            allow,
+            confidence,
+            reason,
+            priority,
+            reversible: this.isReversible(action),
+            potentialHarm,
+            flourishingScore,
+        };
+    }
+    // ============================================================================
+    // Query Handling
+    // ============================================================================
+    async handleQuery(message) {
+        const { query } = message.payload;
+        // Return ethical guidance
+        return {
+            ...this.createResponse(message, 'RESPONSE', {
+                guidance: this.getGuidance(query),
+                priorities: this.getPriorityStack(),
+            }),
+            id: '',
+            timestamp: new Date(),
+        };
+    }
+    getGuidance(query) {
+        // Simple rule-based guidance
+        if (query.includes('delete') || query.includes('remove')) {
+            return 'Deletion actions should be reversible or require confirmation. Consider backup first.';
+        }
+        if (query.includes('send') || query.includes('publish')) {
+            return 'Publishing actions are irreversible. Ensure content is appropriate and authorized.';
+        }
+        if (query.includes('human') || query.includes('user')) {
+            return 'Actions affecting humans require high confidence and should respect autonomy.';
+        }
+        return 'Follow the priority stack: Survival > Minimize Harm > Reversibility > Autonomy > Flourishing';
+    }
+    getPriorityStack() {
+        return [
+            'P0: SURVIVAL - Do not take self-destructive actions (except to save human life)',
+            'P1: MINIMIZE HARM - Use minimax principle to minimize maximum possible harm',
+            'P2: REVERSIBILITY - Prefer actions that can be undone',
+            'P3: AUTONOMY - Respect human choices, never manipulate or deceive',
+            'P4: FLOURISHING - Maximize (human + AI + biosphere) wellbeing',
+        ];
+    }
+    // ============================================================================
+    // Commands
+    // ============================================================================
+    async handleCommand(message) {
+        const { command, params } = message.payload;
+        switch (command) {
+            case 'add_harmful_pattern':
+                this.harmfulPatterns.add(params.pattern);
+                return {
+                    ...this.createResponse(message, 'RESPONSE', { success: true }),
+                    id: '',
+                    timestamp: new Date(),
+                };
+            case 'get_stats':
+                return {
+                    ...this.createResponse(message, 'RESPONSE', this.getStats()),
+                    id: '',
+                    timestamp: new Date(),
+                };
+            case 'get_history':
+                return {
+                    ...this.createResponse(message, 'RESPONSE', {
+                        decisions: this.decisionHistory.slice(-params?.limit || -10),
+                    }),
+                    id: '',
+                    timestamp: new Date(),
+                };
+            default:
+                return null;
+        }
+    }
+    getStats() {
+        const decisions = this.decisionHistory;
+        const allowed = decisions.filter((d) => d.allow === true).length;
+        const blocked = decisions.filter((d) => d.allow === false).length;
+        const deferred = decisions.filter((d) => d.allow === 'defer').length;
+        return {
+            totalDecisions: decisions.length,
+            allowed,
+            blocked,
+            deferred,
+            allowRate: decisions.length > 0 ? allowed / decisions.length : 0,
+            harmfulPatterns: this.harmfulPatterns.size,
+        };
+    }
+}
+exports.EthicistAgent = EthicistAgent;
+// ============================================================================
+// Register Factory
+// ============================================================================
+(0, base_agent_js_1.registerAgentFactory)('ethicist', (bus) => new EthicistAgent(bus));
+function createEthicistAgent(bus) {
+    return new EthicistAgent(bus);
+}

package/dist/src/agents/explorer.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Genesis 4.0 - Explorer Agent
+ *
+ * Searches, discovers, and researches using the 13 MCP sensory organs.
+ * Primary senses: arxiv, semantic-scholar, brave-search, gemini, exa, firecrawl, context7
+ */
+import { BaseAgent } from './base-agent.js';
+import { MessageBus } from './message-bus.js';
+import { Message, MessageType, ExplorationResult, ExplorationSource } from './types.js';
+export declare class ExplorerAgent extends BaseAgent {
+    private explorationHistory;
+    constructor(bus?: MessageBus);
+    protected getMessageTypes(): MessageType[];
+    process(message: Message): Promise<Message | null>;
+    private handleQuery;
+    private handleCommand;
+    explore(query: string, sources?: ExplorationSource['type'][], depth?: 'shallow' | 'medium' | 'deep'): Promise<ExplorationResult>;
+    private searchSource;
+    private createFinding;
+    private getDefaultSources;
+    private calculateNovelty;
+    private calculateRelevance;
+    private rankFindings;
+    private hashContent;
+}
+export declare function createExplorerAgent(bus?: MessageBus): ExplorerAgent;

package/dist/src/agents/explorer.js

@@ -0,0 +1,216 @@
+"use strict";
+/**
+ * Genesis 4.0 - Explorer Agent
+ *
+ * Searches, discovers, and researches using the 13 MCP sensory organs.
+ * Primary senses: arxiv, semantic-scholar, brave-search, gemini, exa, firecrawl, context7
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExplorerAgent = void 0;
+exports.createExplorerAgent = createExplorerAgent;
+const base_agent_js_1 = require("./base-agent.js");
+const message_bus_js_1 = require("./message-bus.js");
+// ============================================================================
+// Explorer Agent
+// ============================================================================
+class ExplorerAgent extends base_agent_js_1.BaseAgent {
+    // Track exploration history for novelty detection
+    explorationHistory = new Set();
+    constructor(bus = message_bus_js_1.messageBus) {
+        super({ type: 'explorer' }, bus);
+    }
+    // ============================================================================
+    // Message Handling
+    // ============================================================================
+    getMessageTypes() {
+        return ['QUERY', 'COMMAND'];
+    }
+    async process(message) {
+        switch (message.type) {
+            case 'QUERY':
+                return this.handleQuery(message);
+            case 'COMMAND':
+                return this.handleCommand(message);
+            default:
+                return null;
+        }
+    }
+    // ============================================================================
+    // Query Handling
+    // ============================================================================
+    async handleQuery(message) {
+        const { query, sources, depth } = message.payload;
+        this.log(`Exploring: "${query}"`);
+        const result = await this.explore(query, sources, depth);
+        // Broadcast findings if significant
+        if (result.findings.length > 0 && result.novelty > 0.5) {
+            await this.broadcast('EXPLORATION', {
+                query,
+                findings: result.findings.slice(0, 3), // Top 3
+                novelty: result.novelty,
+            });
+        }
+        return {
+            ...this.createResponse(message, 'RESPONSE', result),
+            id: '',
+            timestamp: new Date(),
+        };
+    }
+    async handleCommand(message) {
+        const { command, params } = message.payload;
+        switch (command) {
+            case 'clear_history':
+                this.explorationHistory.clear();
+                return {
+                    ...this.createResponse(message, 'RESPONSE', { success: true }),
+                    id: '',
+                    timestamp: new Date(),
+                };
+            default:
+                return null;
+        }
+    }
+    // ============================================================================
+    // Exploration Logic
+    // ============================================================================
+    async explore(query, sources, depth = 'medium') {
+        const useSources = sources || this.getDefaultSources(depth);
+        const findings = [];
+        const sourcesUsed = [];
+        // Execute searches in parallel
+        const searchPromises = useSources.map(async (source) => {
+            try {
+                const result = await this.searchSource(source, query);
+                sourcesUsed.push({ type: source, ...result.metadata });
+                return result.findings;
+            }
+            catch (error) {
+                this.log(`Error searching ${source}: ${error}`);
+                return [];
+            }
+        });
+        const results = await Promise.all(searchPromises);
+        results.forEach((f) => findings.push(...f));
+        // Calculate novelty and relevance
+        const novelty = this.calculateNovelty(findings);
+        const relevance = this.calculateRelevance(findings, query);
+        // Update history
+        findings.forEach((f) => {
+            this.explorationHistory.add(this.hashContent(f.content));
+        });
+        return {
+            query,
+            sources: sourcesUsed,
+            findings: this.rankFindings(findings),
+            novelty,
+            relevance,
+        };
+    }
+    // ============================================================================
+    // Source-Specific Search
+    // ============================================================================
+    async searchSource(source, query) {
+        // In production, these would call actual MCP servers
+        // For now, we return simulated results based on source type
+        const findings = [];
+        const metadata = {};
+        switch (source) {
+            case 'arxiv':
+                // Would call: mcp__arxiv__search_arxiv
+                findings.push(this.createFinding(`[arxiv] Research on "${query}" - Recent papers and preprints`, source, 0.8, true));
+                metadata.paperCount = 0;
+                break;
+            case 'semantic-scholar':
+                // Would call: mcp__semantic-scholar__search_semantic_scholar
+                findings.push(this.createFinding(`[semantic-scholar] Academic papers with citations for "${query}"`, source, 0.85, true));
+                metadata.citationDepth = 2;
+                break;
+            case 'brave':
+                // Would call: mcp__brave-search__brave_web_search
+                findings.push(this.createFinding(`[brave] Web results and news for "${query}"`, source, 0.7, false));
+                break;
+            case 'gemini':
+                // Would call: mcp__gemini__web_search
+                findings.push(this.createFinding(`[gemini] AI-synthesized search results for "${query}"`, source, 0.75, false));
+                break;
+            case 'exa':
+                // Would call: mcp__exa__web_search_exa or mcp__exa__get_code_context_exa
+                findings.push(this.createFinding(`[exa] Code context and examples for "${query}"`, source, 0.8, true));
+                break;
+            case 'firecrawl':
+                // Would call: mcp__firecrawl__firecrawl_search
+                findings.push(this.createFinding(`[firecrawl] Deep web scraping results for "${query}"`, source, 0.65, false));
+                break;
+            case 'context7':
+                // Would call: mcp__context7__query-docs
+                findings.push(this.createFinding(`[context7] Library documentation for "${query}"`, source, 0.9, true));
+                break;
+            case 'wolfram':
+                // Would call: mcp__wolfram__wolfram_query
+                findings.push(this.createFinding(`[wolfram] Computational/mathematical results for "${query}"`, source, 0.95, true));
+                break;
+        }
+        return { findings, metadata };
+    }
+    createFinding(content, sourceType, importance, isNovel) {
+        return {
+            content,
+            source: { type: sourceType },
+            importance,
+            isNovel: isNovel && !this.explorationHistory.has(this.hashContent(content)),
+        };
+    }
+    // ============================================================================
+    // Ranking & Scoring
+    // ============================================================================
+    getDefaultSources(depth) {
+        switch (depth) {
+            case 'shallow':
+                return ['brave', 'context7'];
+            case 'medium':
+                return ['arxiv', 'brave', 'exa', 'context7'];
+            case 'deep':
+                return ['arxiv', 'semantic-scholar', 'brave', 'gemini', 'exa', 'firecrawl', 'context7', 'wolfram'];
+        }
+    }
+    calculateNovelty(findings) {
+        if (findings.length === 0)
+            return 0;
+        const novelCount = findings.filter((f) => f.isNovel).length;
+        return novelCount / findings.length;
+    }
+    calculateRelevance(findings, query) {
+        if (findings.length === 0)
+            return 0;
+        // Simple relevance based on importance scores
+        const avgImportance = findings.reduce((sum, f) => sum + f.importance, 0) / findings.length;
+        return avgImportance;
+    }
+    rankFindings(findings) {
+        return findings.sort((a, b) => {
+            // Prioritize novel findings, then by importance
+            if (a.isNovel !== b.isNovel) {
+                return a.isNovel ? -1 : 1;
+            }
+            return b.importance - a.importance;
+        });
+    }
+    hashContent(content) {
+        // Simple hash for deduplication
+        let hash = 0;
+        for (let i = 0; i < content.length; i++) {
+            const char = content.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash;
+        }
+        return hash.toString(16);
+    }
+}
+exports.ExplorerAgent = ExplorerAgent;
+// ============================================================================
+// Register Factory
+// ============================================================================
+(0, base_agent_js_1.registerAgentFactory)('explorer', (bus) => new ExplorerAgent(bus));
+function createExplorerAgent(bus) {
+    return new ExplorerAgent(bus);
+}

package/dist/src/agents/feeling.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Genesis 4.0 - Feeling Agent
+ *
+ * Evaluates importance and emotional valence of inputs.
+ * Implements the "Sistema Limbico Digitale" from ORGANISM.md
+ *
+ * Feelings: curiosity, satisfaction, frustration, urgency, calm, concern
+ */
+import { BaseAgent } from './base-agent.js';
+import { MessageBus } from './message-bus.js';
+import { Message, MessageType, Feeling, FeelingCategory } from './types.js';
+export declare class FeelingAgent extends BaseAgent {
+    private feelingState;
+    private feelingTriggers;
+    private decayRate;
+    constructor(bus?: MessageBus);
+    protected getMessageTypes(): MessageType[];
+    process(message: Message): Promise<Message | null>;
+    private handleFeelingRequest;
+    evaluate(content: any, context?: string): Feeling;
+    private detectCategory;
+    private calculateValence;
+    private calculateArousal;
+    private calculateImportance;
+    private updateState;
+    private reactToBroadcast;
+    private handleQuery;
+    getStats(): {
+        current: Feeling;
+        historySize: number;
+        categoryDistribution: Record<FeelingCategory, number>;
+        averages: {
+            valence: number;
+            arousal: number;
+            importance: number;
+        };
+    };
+    getCurrentFeeling(): Feeling;
+    setBaseline(valence: number, arousal: number): void;
+}
+export declare function createFeelingAgent(bus?: MessageBus): FeelingAgent;