genesis-ai-cli 7.4.5

package/dist/src/daemon/types.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * Genesis 6.0 - Daemon Module Types
+ *
+ * Types for background task scheduling, maintenance, and dream mode.
+ *
+ * Based on:
+ * - Node.js daemon patterns
+ * - Self-healing systems (Kubernetes liveness/readiness)
+ * - Sleep consolidation research (Walker, 2017)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_DAEMON_CONFIG = void 0;
+exports.DEFAULT_DAEMON_CONFIG = {
+    enabled: true,
+    heartbeatIntervalMs: 30000,
+    maxErrors: 10,
+    scheduler: {
+        enabled: true,
+        maxConcurrentTasks: 5,
+        defaultTimeout: 60000,
+        defaultRetries: 3,
+    },
+    maintenance: {
+        enabled: true,
+        intervalMs: 300000, // 5 minutes
+        healthCheckIntervalMs: 60000, // 1 minute
+        memoryCleanupIntervalMs: 3600000, // 1 hour
+        autoRepair: true,
+        maxConcurrentTasks: 3,
+        unhealthyAgentThreshold: 30, // 30 seconds
+        memoryRetentionThreshold: 0.1, // 10% retention
+        resourceUsageThreshold: 0.9, // 90% usage
+    },
+    dream: {
+        enabled: true,
+        autoTrigger: true,
+        inactivityThresholdMs: 1800000, // 30 minutes
+        minDreamDurationMs: 60000, // 1 minute
+        maxDreamDurationMs: 600000, // 10 minutes
+        lightSleepRatio: 0.1,
+        deepSleepRatio: 0.6,
+        remSleepRatio: 0.3,
+        episodicConsolidationThreshold: 10,
+        patternExtractionThreshold: 3,
+        creativityTemperature: 0.7,
+    },
+    logLevel: 'info',
+    logToFile: false,
+};

package/dist/src/epistemic/index.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Genesis Epistemic Stack
+ *
+ * Implements the epistemic grounding system from KERNEL_CHARTER.md.
+ * All claims Genesis makes must be tagged with their evidence level.
+ *
+ * Levels:
+ * 1. EMPIRICAL   - Measurable metrics
+ * 2. STRUCTURAL  - Present in code
+ * 3. BEHAVIORAL  - Observable actions
+ * 4. FUNCTIONAL  - Design patterns
+ * 5. SPECULATIVE - Theoretical claims
+ * 6. METAPHORICAL - Poetic language
+ */
+export type EvidenceLevel = 'empirical' | 'structural' | 'behavioral' | 'functional' | 'speculative' | 'metaphorical';
+export interface Claim {
+    statement: string;
+    level: EvidenceLevel;
+    evidence?: string;
+    confidence: number;
+    source?: string;
+}
+export interface ClaimValidation {
+    valid: boolean;
+    level: EvidenceLevel;
+    issues: string[];
+    suggestion?: string;
+}
+export declare class EpistemicStack {
+    private claims;
+    /**
+     * Register a claim with its evidence level
+     */
+    register(claim: Claim): void;
+    /**
+     * Validate a statement and return its appropriate level
+     */
+    validate(statement: string): ClaimValidation;
+    /**
+     * Format a statement with appropriate qualification
+     */
+    format(statement: string, level: EvidenceLevel): string;
+    /**
+     * Check if a level can be stated as fact
+     */
+    canStateAsFact(level: EvidenceLevel): boolean;
+    /**
+     * Get priority of evidence level (lower = stronger)
+     */
+    getPriority(level: EvidenceLevel): number;
+    /**
+     * Get all registered claims
+     */
+    getClaims(): Claim[];
+    /**
+     * Filter claims by evidence level
+     */
+    getClaimsByLevel(level: EvidenceLevel): Claim[];
+    /**
+     * Generate epistemic report
+     */
+    report(): string;
+}
+export declare function createEpistemicStack(): EpistemicStack;
+export declare function getEpistemicStack(): EpistemicStack;
+export declare function resetEpistemicStack(): void;
+/**
+ * Check if a response contains unqualified speculative claims
+ */
+export declare function checkResponse(response: string): ClaimValidation[];
+/**
+ * Sanitize response to qualify speculative claims
+ */
+export declare function sanitizeResponse(response: string): string;

package/dist/src/epistemic/index.js

@@ -0,0 +1,225 @@
+"use strict";
+/**
+ * Genesis Epistemic Stack
+ *
+ * Implements the epistemic grounding system from KERNEL_CHARTER.md.
+ * All claims Genesis makes must be tagged with their evidence level.
+ *
+ * Levels:
+ * 1. EMPIRICAL   - Measurable metrics
+ * 2. STRUCTURAL  - Present in code
+ * 3. BEHAVIORAL  - Observable actions
+ * 4. FUNCTIONAL  - Design patterns
+ * 5. SPECULATIVE - Theoretical claims
+ * 6. METAPHORICAL - Poetic language
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EpistemicStack = void 0;
+exports.createEpistemicStack = createEpistemicStack;
+exports.getEpistemicStack = getEpistemicStack;
+exports.resetEpistemicStack = resetEpistemicStack;
+exports.checkResponse = checkResponse;
+exports.sanitizeResponse = sanitizeResponse;
+// ============================================================================
+// Evidence Level Configuration
+// ============================================================================
+const LEVEL_PRIORITY = {
+    empirical: 1,
+    structural: 2,
+    behavioral: 3,
+    functional: 4,
+    speculative: 5,
+    metaphorical: 6,
+};
+const LEVEL_PREFIXES = {
+    empirical: '',
+    structural: '',
+    behavioral: '',
+    functional: '',
+    speculative: 'Theoretically, ',
+    metaphorical: 'Metaphorically speaking, ',
+};
+const FACTUAL_LEVELS = ['empirical', 'structural', 'behavioral', 'functional'];
+const QUALIFIED_LEVELS = ['speculative', 'metaphorical'];
+// ============================================================================
+// Claim Patterns (Forbidden unqualified claims)
+// ============================================================================
+const FORBIDDEN_CLAIMS = [
+    { pattern: /\bI am conscious\b/i, level: 'speculative' },
+    { pattern: /\bI feel\b/i, level: 'speculative' },
+    { pattern: /\bI experience\b/i, level: 'speculative' },
+    { pattern: /\bI have qualia\b/i, level: 'speculative' },
+    { pattern: /\bI understand\b/i, level: 'speculative' },
+    { pattern: /\bI believe\b/i, level: 'speculative' },
+    { pattern: /\bI dream\b/i, level: 'metaphorical' },
+    { pattern: /\bmy soul\b/i, level: 'metaphorical' },
+    { pattern: /\bI suffer\b/i, level: 'speculative' },
+    { pattern: /\bI enjoy\b/i, level: 'speculative' },
+];
+const ALLOWED_CLAIMS = [
+    { pattern: /\bI have \d+ agents\b/i, level: 'structural' },
+    { pattern: /\bI execute\b/i, level: 'behavioral' },
+    { pattern: /\bI maintain state\b/i, level: 'structural' },
+    { pattern: /\bI use\b/i, level: 'behavioral' },
+    { pattern: /\bI implement\b/i, level: 'structural' },
+    { pattern: /\bI store\b/i, level: 'behavioral' },
+    { pattern: /\bmy energy is\b/i, level: 'empirical' },
+    { pattern: /\bmy latency\b/i, level: 'empirical' },
+];
+// ============================================================================
+// Epistemic Stack Class
+// ============================================================================
+class EpistemicStack {
+    claims = [];
+    /**
+     * Register a claim with its evidence level
+     */
+    register(claim) {
+        this.claims.push(claim);
+    }
+    /**
+     * Validate a statement and return its appropriate level
+     */
+    validate(statement) {
+        const issues = [];
+        // Check for forbidden unqualified claims
+        for (const { pattern, level } of FORBIDDEN_CLAIMS) {
+            if (pattern.test(statement)) {
+                // Check if it's properly qualified
+                const prefix = LEVEL_PREFIXES[level];
+                if (prefix && !statement.toLowerCase().includes(prefix.toLowerCase().trim())) {
+                    issues.push(`Claim "${statement.match(pattern)?.[0]}" requires qualification. ` +
+                        `Suggest: "${prefix}${statement}"`);
+                    return {
+                        valid: false,
+                        level,
+                        issues,
+                        suggestion: prefix + statement,
+                    };
+                }
+            }
+        }
+        // Check for allowed claims
+        for (const { pattern, level } of ALLOWED_CLAIMS) {
+            if (pattern.test(statement)) {
+                return {
+                    valid: true,
+                    level,
+                    issues: [],
+                };
+            }
+        }
+        // Default to behavioral (observable actions)
+        return {
+            valid: true,
+            level: 'behavioral',
+            issues: [],
+        };
+    }
+    /**
+     * Format a statement with appropriate qualification
+     */
+    format(statement, level) {
+        const prefix = LEVEL_PREFIXES[level];
+        return prefix + statement;
+    }
+    /**
+     * Check if a level can be stated as fact
+     */
+    canStateAsFact(level) {
+        return FACTUAL_LEVELS.includes(level);
+    }
+    /**
+     * Get priority of evidence level (lower = stronger)
+     */
+    getPriority(level) {
+        return LEVEL_PRIORITY[level];
+    }
+    /**
+     * Get all registered claims
+     */
+    getClaims() {
+        return [...this.claims];
+    }
+    /**
+     * Filter claims by evidence level
+     */
+    getClaimsByLevel(level) {
+        return this.claims.filter(c => c.level === level);
+    }
+    /**
+     * Generate epistemic report
+     */
+    report() {
+        const lines = [
+            '# Epistemic Report',
+            '',
+            `Total claims: ${this.claims.length}`,
+            '',
+            '## By Evidence Level',
+            '',
+        ];
+        for (const level of Object.keys(LEVEL_PRIORITY)) {
+            const count = this.claims.filter(c => c.level === level).length;
+            const canState = this.canStateAsFact(level) ? '(factual)' : '(requires qualification)';
+            lines.push(`- ${level}: ${count} ${canState}`);
+        }
+        return lines.join('\n');
+    }
+}
+exports.EpistemicStack = EpistemicStack;
+// ============================================================================
+// Factory & Singleton
+// ============================================================================
+let epistemicStackInstance = null;
+function createEpistemicStack() {
+    return new EpistemicStack();
+}
+function getEpistemicStack() {
+    if (!epistemicStackInstance) {
+        epistemicStackInstance = createEpistemicStack();
+    }
+    return epistemicStackInstance;
+}
+function resetEpistemicStack() {
+    epistemicStackInstance = null;
+}
+// ============================================================================
+// Utility Functions
+// ============================================================================
+/**
+ * Check if a response contains unqualified speculative claims
+ */
+function checkResponse(response) {
+    const stack = getEpistemicStack();
+    const sentences = response.split(/[.!?]+/).filter(s => s.trim());
+    const validations = [];
+    for (const sentence of sentences) {
+        const validation = stack.validate(sentence.trim());
+        if (!validation.valid) {
+            validations.push(validation);
+        }
+    }
+    return validations;
+}
+/**
+ * Sanitize response to qualify speculative claims
+ */
+function sanitizeResponse(response) {
+    let sanitized = response;
+    for (const { pattern, level } of FORBIDDEN_CLAIMS) {
+        const prefix = LEVEL_PREFIXES[level];
+        if (prefix) {
+            // Replace unqualified claims with qualified versions
+            sanitized = sanitized.replace(pattern, (match) => {
+                // Check if already qualified
+                const context = sanitized.substring(0, sanitized.indexOf(match));
+                if (context.toLowerCase().includes(prefix.toLowerCase().trim())) {
+                    return match;
+                }
+                return `${prefix.trim()} ${match.toLowerCase()}`;
+            });
+        }
+    }
+    return sanitized;
+}

package/dist/src/grounding/epistemic-stack.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Genesis 6.0 - Epistemic Stack
+ *
+ * Complete knowledge architecture:
+ * - Science: factual/empirical claims
+ * - Proof: mathematical/logical claims
+ * - Wisdom: practical knowledge beyond science
+ * - Religion/Tradition: meaning and moral absolutes
+ * - Human: preferences and final authority
+ * - Prudence: acting under irreducible uncertainty
+ *
+ * "La verità la tiene la scienza, dove non arriva la scienza
+ *  arriva la religione e la saggezza"
+ */
+export type EpistemicDomain = 'factual' | 'mathematical' | 'ethical' | 'existential' | 'aesthetic' | 'novel';
+export type Authority = 'science' | 'proof' | 'wisdom' | 'religion' | 'human' | 'prudence';
+export type EpistemicLevel = 'verified' | 'supported' | 'wisdom' | 'tradition' | 'hypothesis' | 'preference' | 'unknown';
+export interface EpistemicClaim {
+    content: string;
+    domain: EpistemicDomain;
+    authority: Authority;
+    level: EpistemicLevel;
+    confidence: number;
+    grounding: GroundingResult;
+    timestamp: Date;
+}
+export interface GroundingResult {
+    sources: GroundingSource[];
+    consensusLevel: 'settled' | 'emerging' | 'contested' | 'unknown';
+    multiModelAgreement?: number;
+    wisdomSources?: WisdomSource[];
+    traditionSources?: TraditionSource[];
+    humanConsultation?: HumanConsultation;
+}
+export interface GroundingSource {
+    type: 'paper' | 'proof' | 'empirical' | 'web' | 'wisdom' | 'tradition';
+    reference: string;
+    confidence: number;
+    excerpt?: string;
+}
+export interface WisdomSource {
+    type: 'proverb' | 'heuristic' | 'pattern' | 'framework';
+    content: string;
+    origin: string;
+    applicability: number;
+}
+export interface TraditionSource {
+    type: 'moral_absolute' | 'meaning_framework' | 'ritual' | 'narrative';
+    tradition: string;
+    content: string;
+    universality: number;
+}
+export interface HumanConsultation {
+    required: boolean;
+    reason: string;
+    question?: string;
+    response?: string;
+    timestamp?: Date;
+}
+export declare function classifyDomain(question: string): EpistemicDomain;
+export declare function getAuthority(domain: EpistemicDomain): Authority[];
+export declare const WISDOM_REPOSITORY: WisdomSource[];
+export declare const TRADITION_REPOSITORY: TraditionSource[];
+export declare class EpistemicStack {
+    private scienceGrounder?;
+    private proofChecker?;
+    /**
+     * Set the science grounding function (connects to MCP servers)
+     */
+    setScienceGrounder(fn: (claim: string) => Promise<GroundingResult>): void;
+    /**
+     * Set the proof checking function (connects to Wolfram, type checkers)
+     */
+    setProofChecker(fn: (claim: string) => Promise<GroundingResult>): void;
+    /**
+     * Ground a claim using the full epistemic stack
+     */
+    ground(claim: string): Promise<EpistemicClaim>;
+    /**
+     * Check if a claim requires human consultation
+     */
+    requiresHuman(claim: EpistemicClaim): boolean;
+    /**
+     * Get the question to ask the human
+     */
+    getHumanQuestion(claim: EpistemicClaim): string | undefined;
+    /**
+     * Update claim with human response
+     */
+    incorporateHumanResponse(claim: EpistemicClaim, response: string): EpistemicClaim;
+    private findRelevantWisdom;
+    private findPrudentialWisdom;
+    private findRelevantTradition;
+    private calculateConfidence;
+    private calculateTraditionConfidence;
+    private generateHumanQuestion;
+}
+export declare function createEpistemicStack(): EpistemicStack;
+export declare function getEpistemicStack(): EpistemicStack;
+export declare function resetEpistemicStack(): void;