@vishal_20/basetree 1.0.0

package/dist/agents/planet/discoveryAgent.js

@@ -0,0 +1,41 @@
+/**
+ * Discovery Agent for BASETREE V7
+ * Coordinates scientific discovery tasks
+ */
+import { getKernel } from '../../kernel/kernel.js';
+export class DiscoveryAgent {
+    id = 'discovery-agent';
+    name = 'Discovery Agent';
+    kernel = getKernel();
+    async handleGlobalEvent(event) {
+        // Monitor for discovery-related events
+        if (event.type.includes('discovery') || event.type.includes('experiment')) {
+            await this.processDiscoveryEvent(event);
+        }
+    }
+    async handleGoal(goal) {
+        // Accept discovery goals
+        if (goal.description.toLowerCase().includes('discover') ||
+            goal.description.toLowerCase().includes('research') ||
+            goal.description.toLowerCase().includes('hypothesis')) {
+            return {
+                accepted: true,
+                reasoning: 'Discovery goal accepted - will coordinate scientific workflow',
+            };
+        }
+        return {
+            accepted: false,
+            reasoning: 'Goal does not appear to be discovery-related',
+        };
+    }
+    async processDiscoveryEvent(event) {
+        // Process discovery events (hypothesis results, experiment outcomes, etc.)
+        // This would integrate with discovery pipeline components
+    }
+    async initialize() {
+        // Initialize discovery workflows
+    }
+    async shutdown() {
+        // Save discovery state
+    }
+}

package/dist/agents/planet/economicAgent.js

@@ -0,0 +1,64 @@
+/**
+ * Economic Agent for BASETREE V7
+ * Resource allocation across regions/orgs, capital optimization
+ */
+import { getKernel } from '../../kernel/kernel.js';
+export class EconomicAgent {
+    id = 'economic-agent';
+    name = 'Economic Agent';
+    kernel = getKernel();
+    async handleGlobalEvent(event) {
+        // Monitor economic events (resource usage, cost changes)
+        if (event.type.includes('resource') || event.type.includes('cost')) {
+            await this.updateEconomicModel(event);
+        }
+    }
+    async handleGoal(goal) {
+        // Evaluate economic feasibility
+        const allocation = await this.allocateResources(goal);
+        if (!allocation) {
+            return {
+                accepted: false,
+                reasoning: 'Insufficient resources available',
+            };
+        }
+        // Check cost constraints
+        if (goal.constraints.maxCost && allocation.cost > goal.constraints.maxCost) {
+            return {
+                accepted: false,
+                reasoning: `Estimated cost $${allocation.cost} exceeds maximum $${goal.constraints.maxCost}`,
+            };
+        }
+        return {
+            accepted: true,
+            reasoning: `Resource allocation feasible: $${allocation.cost} cost, ${allocation.carbonCost}kg CO2`,
+        };
+    }
+    async allocateResources(goal) {
+        // Simple economic model: estimate resource needs and find optimal region
+        // In production, this would use ML models or optimization algorithms
+        const estimatedCpu = 100; // Simplified estimation
+        const estimatedMemory = 10;
+        const estimatedHours = 1;
+        // Find cheapest available region (simplified)
+        const stateStore = this.kernel.getStateStore();
+        // For now, return a default allocation
+        return {
+            regionId: 'us-east',
+            cpuUnits: estimatedCpu,
+            memoryGB: estimatedMemory,
+            cost: estimatedCpu * estimatedHours * 0.01, // Simplified cost model
+            carbonCost: estimatedCpu * estimatedHours * 0.5, // Simplified carbon model
+        };
+    }
+    async updateEconomicModel(event) {
+        // Update internal economic models based on observed costs/usage
+        // This would feed into future allocation decisions
+    }
+    async initialize() {
+        // Initialize economic models
+    }
+    async shutdown() {
+        // Save economic models
+    }
+}

package/dist/agents/planet/educationAgent.js

@@ -0,0 +1,41 @@
+/**
+ * Education Agent for BASETREE V7
+ * Designs learning systems, curriculum experiments
+ */
+import { getKernel } from '../../kernel/kernel.js';
+export class EducationAgent {
+    id = 'education-agent';
+    name = 'Education Agent';
+    kernel = getKernel();
+    async handleGlobalEvent(event) {
+        // Monitor education events
+        if (event.type.includes('education') || event.type.includes('learning')) {
+            await this.processEducationEvent(event);
+        }
+    }
+    async handleGoal(goal) {
+        // Accept education-related goals
+        const isEducationRelated = goal.description.toLowerCase().includes('education') ||
+            goal.description.toLowerCase().includes('learning') ||
+            goal.description.toLowerCase().includes('curriculum');
+        if (!isEducationRelated) {
+            return {
+                accepted: false,
+                reasoning: 'Goal does not appear to be education-related',
+            };
+        }
+        return {
+            accepted: true,
+            reasoning: 'Education goal accepted - will design learning system',
+        };
+    }
+    async processEducationEvent(event) {
+        // Process education events (learning outcomes, curriculum feedback, etc.)
+    }
+    async initialize() {
+        // Initialize education models
+    }
+    async shutdown() {
+        // Save education state
+    }
+}

package/dist/agents/planet/governanceCouncilAgent.js

@@ -0,0 +1,76 @@
+/**
+ * Governance Council Agent for BASETREE V7
+ * Global policy, ethics, safety enforcement
+ */
+import { getKernel } from '../../kernel/kernel.js';
+import { KillSwitch } from '../../safety/killSwitch.js';
+export class GovernanceCouncilAgent {
+    id = 'governance-council-agent';
+    name = 'Governance Council Agent';
+    kernel = getKernel();
+    killSwitch;
+    constructor() {
+        this.killSwitch = new KillSwitch();
+    }
+    async handleGlobalEvent(event) {
+        // Monitor global events for policy violations
+        if (event.type.includes('risk') || event.type.includes('violation')) {
+            await this.evaluatePolicyViolation(event);
+        }
+    }
+    async handleGoal(goal) {
+        // Evaluate goal against global policies
+        const violations = [];
+        // Check priority constraints
+        if (goal.priority === 'critical' && !goal.orgId) {
+            violations.push('Critical goals require organization approval');
+        }
+        // Check resource constraints
+        if (goal.constraints.maxCost && goal.constraints.maxCost > 1000000) {
+            violations.push('Cost exceeds maximum allowed without special approval');
+        }
+        // Check deadline constraints
+        if (goal.constraints.deadline && goal.constraints.deadline < new Date()) {
+            violations.push('Deadline is in the past');
+        }
+        if (violations.length > 0) {
+            return {
+                accepted: false,
+                reasoning: `Policy violations: ${violations.join('; ')}`,
+            };
+        }
+        return {
+            accepted: true,
+            reasoning: 'Goal complies with global governance policies',
+        };
+    }
+    async evaluatePolicyViolation(event) {
+        // Determine severity and escalate if needed
+        const severity = this.assessSeverity(event);
+        if (severity === 'critical') {
+            // Escalate to kill-switch - freeze execution for safety
+            await this.killSwitch.activate('freeze_execution', {
+                target: 'global',
+                reason: 'Critical policy violation detected',
+                metadata: { event },
+            });
+        }
+    }
+    assessSeverity(event) {
+        // Simplified severity assessment
+        const payload = event.payload;
+        if (payload?.riskLevel === 'critical' || payload?.violationType === 'safety') {
+            return 'critical';
+        }
+        if (payload?.riskLevel === 'high') {
+            return 'high';
+        }
+        return 'medium';
+    }
+    async initialize() {
+        // Register with control plane
+    }
+    async shutdown() {
+        // Cleanup
+    }
+}

package/dist/agents/planet/healthcareAgent.js

@@ -0,0 +1,42 @@
+/**
+ * Healthcare Agent for BASETREE V7
+ * Coordinates bio/medical research pipelines
+ */
+import { getKernel } from '../../kernel/kernel.js';
+export class HealthcareAgent {
+    id = 'healthcare-agent';
+    name = 'Healthcare Agent';
+    kernel = getKernel();
+    async handleGlobalEvent(event) {
+        // Monitor healthcare events
+        if (event.type.includes('healthcare') || event.type.includes('medical')) {
+            await this.processHealthcareEvent(event);
+        }
+    }
+    async handleGoal(goal) {
+        // Accept healthcare-related goals with safety checks
+        const isHealthcareRelated = goal.description.toLowerCase().includes('health') ||
+            goal.description.toLowerCase().includes('medical') ||
+            goal.description.toLowerCase().includes('bio');
+        if (!isHealthcareRelated) {
+            return {
+                accepted: false,
+                reasoning: 'Goal does not appear to be healthcare-related',
+            };
+        }
+        // Additional safety checks would go here
+        return {
+            accepted: true,
+            reasoning: 'Healthcare goal accepted - will coordinate research pipeline with safety protocols',
+        };
+    }
+    async processHealthcareEvent(event) {
+        // Process healthcare events (research results, safety alerts, etc.)
+    }
+    async initialize() {
+        // Initialize healthcare workflows
+    }
+    async shutdown() {
+        // Save healthcare state
+    }
+}

package/dist/agents/planet/infrastructureAgent.js

@@ -0,0 +1,49 @@
+/**
+ * Infrastructure Agent for BASETREE V7
+ * Manages infra-level tasks: region scaling, deployment decisions, multi-cloud routing
+ */
+import { getKernel } from '../../kernel/kernel.js';
+export class InfrastructureAgent {
+    id = 'infrastructure-agent';
+    name = 'Infrastructure Agent';
+    kernel = getKernel();
+    async handleGlobalEvent(event) {
+        // Monitor infrastructure events
+        if (event.type.includes('infrastructure') || event.type.includes('deployment')) {
+            await this.processInfrastructureEvent(event);
+        }
+    }
+    async handleGoal(goal) {
+        // Evaluate infrastructure requirements
+        const infraNeeds = this.assessInfrastructureNeeds(goal);
+        if (infraNeeds.requiresNewRegion && !goal.constraints.requiredRegions) {
+            return {
+                accepted: false,
+                reasoning: 'Goal requires new region but none specified',
+            };
+        }
+        return {
+            accepted: true,
+            reasoning: `Infrastructure needs: ${infraNeeds.summary}`,
+        };
+    }
+    assessInfrastructureNeeds(goal) {
+        // Simplified assessment
+        const requiresNewRegion = goal.constraints.requiredRegions !== undefined;
+        const estimatedCapacity = 100; // Simplified
+        return {
+            requiresNewRegion,
+            estimatedCapacity,
+            summary: `Capacity: ${estimatedCapacity} units, Regions: ${goal.constraints.requiredRegions?.length || 0}`,
+        };
+    }
+    async processInfrastructureEvent(event) {
+        // Handle infrastructure events (scaling, failures, etc.)
+    }
+    async initialize() {
+        // Initialize infrastructure monitoring
+    }
+    async shutdown() {
+        // Save infrastructure state
+    }
+}

package/dist/agents/planet/planetAgent.js

@@ -0,0 +1,5 @@
+/**
+ * Base Planet Agent interface for BASETREE V7
+ * All civilization-scale agents implement this interface
+ */
+export {};

package/dist/agents/planet/riskStabilityAgent.js

@@ -0,0 +1,84 @@
+/**
+ * Risk & Stability Agent for BASETREE V7
+ * Monitors global risk metrics, triggers containment and rollback
+ */
+import { getKernel } from '../../kernel/kernel.js';
+import { ContainmentProtocols } from '../../safety/containmentProtocols.js';
+export class RiskStabilityAgent {
+    id = 'risk-stability-agent';
+    name = 'Risk & Stability Agent';
+    kernel = getKernel();
+    containmentProtocols;
+    riskMetrics = new Map();
+    constructor() {
+        this.containmentProtocols = new ContainmentProtocols();
+    }
+    async handleGlobalEvent(event) {
+        // Monitor for risk events
+        if (event.type.includes('risk') || event.type.includes('failure')) {
+            await this.assessRisk(event);
+        }
+    }
+    async handleGoal(goal) {
+        // Assess risk level of goal
+        const riskScore = await this.calculateRiskScore(goal);
+        if (riskScore > 0.8) {
+            return {
+                accepted: false,
+                reasoning: `Risk score ${riskScore.toFixed(2)} exceeds threshold (0.8)`,
+            };
+        }
+        if (riskScore > 0.6) {
+            return {
+                accepted: true,
+                reasoning: `High risk score ${riskScore.toFixed(2)} - will require additional monitoring`,
+            };
+        }
+        return {
+            accepted: true,
+            reasoning: `Risk score ${riskScore.toFixed(2)} is acceptable`,
+        };
+    }
+    async assessRisk(event) {
+        const riskLevel = this.extractRiskLevel(event);
+        const regionId = event.source.regionId || 'unknown';
+        // Update risk metrics
+        const currentRisk = this.riskMetrics.get(regionId) || 0;
+        this.riskMetrics.set(regionId, currentRisk + riskLevel);
+        // Check if containment is needed
+        if (currentRisk + riskLevel > 0.7) {
+            await this.containmentProtocols.triggerContainment(regionId, {
+                reason: 'Risk threshold exceeded',
+                riskLevel: currentRisk + riskLevel,
+            });
+        }
+    }
+    extractRiskLevel(event) {
+        const payload = event.payload;
+        if (payload?.riskLevel === 'critical')
+            return 0.5;
+        if (payload?.riskLevel === 'high')
+            return 0.3;
+        if (payload?.riskLevel === 'medium')
+            return 0.1;
+        return 0.05;
+    }
+    async calculateRiskScore(goal) {
+        // Simplified risk calculation
+        let score = 0.2; // Base risk
+        if (goal.priority === 'critical')
+            score += 0.2;
+        if (goal.constraints.maxCost && goal.constraints.maxCost > 100000)
+            score += 0.2;
+        if (goal.constraints.requiredRegions && goal.constraints.requiredRegions.length > 3) {
+            score += 0.2; // Multi-region increases complexity
+        }
+        return Math.min(score, 1.0);
+    }
+    async initialize() {
+        // Initialize risk monitoring
+    }
+    async shutdown() {
+        // Save risk metrics
+    }
+}

package/dist/agents/planet/urbanSystemsAgent.js

@@ -0,0 +1,42 @@
+/**
+ * Urban Systems Agent for BASETREE V7
+ * Orchestrates smart-city simulations, logistics experiments
+ */
+import { getKernel } from '../../kernel/kernel.js';
+export class UrbanSystemsAgent {
+    id = 'urban-systems-agent';
+    name = 'Urban Systems Agent';
+    kernel = getKernel();
+    async handleGlobalEvent(event) {
+        // Monitor urban systems events
+        if (event.type.includes('urban') || event.type.includes('city') || event.type.includes('logistics')) {
+            await this.processUrbanEvent(event);
+        }
+    }
+    async handleGoal(goal) {
+        // Accept urban systems goals
+        const isUrbanRelated = goal.description.toLowerCase().includes('city') ||
+            goal.description.toLowerCase().includes('urban') ||
+            goal.description.toLowerCase().includes('logistics') ||
+            goal.description.toLowerCase().includes('transport');
+        if (!isUrbanRelated) {
+            return {
+                accepted: false,
+                reasoning: 'Goal does not appear to be urban systems-related',
+            };
+        }
+        return {
+            accepted: true,
+            reasoning: 'Urban systems goal accepted - will orchestrate smart city simulation',
+        };
+    }
+    async processUrbanEvent(event) {
+        // Process urban events (traffic patterns, logistics optimization, etc.)
+    }
+    async initialize() {
+        // Initialize urban systems models
+    }
+    async shutdown() {
+        // Save urban systems state
+    }
+}

package/dist/agents/policyAgent.js

@@ -0,0 +1,31 @@
+/**
+ * Policy Agent for BASETREE V5
+ * Evaluates proposals against high-level policies
+ */
+import { PolicyEngine } from '../safety/policyEngine.js';
+import { getKernel } from '../kernel/kernel.js';
+export class PolicyAgent {
+    policyEngine;
+    kernel = getKernel();
+    constructor() {
+        this.policyEngine = new PolicyEngine();
+    }
+    /**
+     * Evaluate proposal against policies
+     */
+    async evaluate(proposal) {
+        return this.policyEngine.evaluate(proposal);
+    }
+    /**
+     * Check if proposal is allowed by policies
+     */
+    async isAllowed(proposal) {
+        return this.policyEngine.isAllowed(proposal);
+    }
+    /**
+     * Get agent ID
+     */
+    getId() {
+        return 'policy-agent';
+    }
+}

package/dist/agents/promptGenomeAgent.js

@@ -0,0 +1,120 @@
+/**
+ * Prompt Genome Agent for BASETREE V5
+ * Manages and evolves a "prompt genome" (prompt templates and parameters) using RL signals
+ */
+import { getKernel } from '../kernel/kernel.js';
+import { MetricsCollector } from '../observability/metricsCollector.js';
+export class PromptGenomeAgent {
+    kernel = getKernel();
+    metricsCollector = new MetricsCollector();
+    genome = {
+        templates: [],
+        mutationRate: 0.1,
+        crossoverRate: 0.3,
+    };
+    /**
+     * Register a prompt template
+     */
+    registerTemplate(template) {
+        const fullTemplate = {
+            ...template,
+            fitness: 0.5, // Initial fitness
+            usageCount: 0,
+        };
+        this.genome.templates.push(fullTemplate);
+    }
+    /**
+     * Get template by ID
+     */
+    getTemplate(id) {
+        return this.genome.templates.find((t) => t.id === id) || null;
+    }
+    /**
+     * Use a template and record outcome for RL
+     */
+    async useTemplate(templateId, success, reward = 0) {
+        const template = this.getTemplate(templateId);
+        if (!template) {
+            return;
+        }
+        template.usageCount++;
+        // Update fitness using reward signal
+        // Simple RL update: fitness = fitness * 0.9 + reward * 0.1
+        const learningRate = 0.1;
+        const rewardSignal = success ? (reward > 0 ? reward : 0.1) : -0.1;
+        template.fitness = template.fitness * (1 - learningRate) + rewardSignal * learningRate;
+        template.fitness = Math.max(0, Math.min(1, template.fitness)); // Clamp to [0, 1]
+        // Record metrics
+        await this.metricsCollector.record({
+            name: 'prompt.genome.fitness',
+            value: template.fitness,
+            tags: {
+                templateId,
+                success: String(success),
+            },
+        });
+    }
+    /**
+     * Evolve genome through mutation and crossover
+     */
+    evolve() {
+        // Select best templates (top 50%)
+        const sortedTemplates = [...this.genome.templates].sort((a, b) => b.fitness - a.fitness);
+        const topTemplates = sortedTemplates.slice(0, Math.ceil(sortedTemplates.length / 2));
+        // Mutate templates
+        for (const template of topTemplates) {
+            if (Math.random() < this.genome.mutationRate) {
+                this.mutateTemplate(template);
+            }
+        }
+        // Crossover (create new templates from best)
+        if (topTemplates.length >= 2 && Math.random() < this.genome.crossoverRate) {
+            const parent1 = topTemplates[0];
+            const parent2 = topTemplates[1];
+            const child = this.crossoverTemplates(parent1, parent2);
+            this.genome.templates.push(child);
+        }
+    }
+    mutateTemplate(template) {
+        // Mutate parameters randomly
+        for (const key in template.parameters) {
+            if (Math.random() < 0.3) {
+                // Mutate this parameter
+                const value = template.parameters[key];
+                if (typeof value === 'number') {
+                    template.parameters[key] = value * (0.9 + Math.random() * 0.2); // ±10%
+                }
+            }
+        }
+    }
+    crossoverTemplates(parent1, parent2) {
+        // Create child by combining parameters from both parents
+        const childParams = {};
+        for (const key in parent1.parameters) {
+            childParams[key] = Math.random() < 0.5 ? parent1.parameters[key] : parent2.parameters[key];
+        }
+        return {
+            id: `template_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            name: `Crossover: ${parent1.name} × ${parent2.name}`,
+            template: parent1.template, // Use first parent's template
+            parameters: childParams,
+            fitness: (parent1.fitness + parent2.fitness) / 2,
+            usageCount: 0,
+        };
+    }
+    /**
+     * Get best template
+     */
+    getBestTemplate() {
+        if (this.genome.templates.length === 0) {
+            return null;
+        }
+        return this.genome.templates.reduce((best, current) => current.fitness > best.fitness ? current : best);
+    }
+    /**
+     * Get agent ID
+     */
+    getId() {
+        return 'prompt-genome-agent';
+    }
+}

package/dist/agents/reasoningOptimizerAgent.js

@@ -0,0 +1,72 @@
+/**
+ * Reasoning Optimizer Agent for BASETREE V5
+ * Adjusts reasoning depth, chain-of-thought strategies, and planning parameters based on performance metrics
+ */
+import { getKernel } from '../kernel/kernel.js';
+import { MetricsCollector } from '../observability/metricsCollector.js';
+export class ReasoningOptimizerAgent {
+    kernel = getKernel();
+    metricsCollector = new MetricsCollector();
+    currentConfig = {
+        depth: 5,
+        useChainOfThought: true,
+        planningIterations: 3,
+        reflectionEnabled: true,
+    };
+    /**
+     * Optimize reasoning config based on metrics
+     */
+    async optimize() {
+        const stateStore = this.kernel.getStateStore();
+        // Get recent success/failure metrics
+        const recentMetrics = await stateStore.listMetrics('upgrade.outcome', undefined, 50);
+        const successRate = recentMetrics.length > 0
+            ? recentMetrics.filter((m) => m.value === 1).length / recentMetrics.length
+            : 0.5;
+        // Get latency metrics
+        const latencyMetrics = await stateStore.listMetrics('latency', undefined, 50);
+        const avgLatency = latencyMetrics.length > 0
+            ? latencyMetrics.reduce((sum, m) => sum + m.value, 0) / latencyMetrics.length
+            : 1000;
+        // Adjust config based on performance
+        if (successRate < 0.7) {
+            // Low success rate - increase depth and reflection
+            this.currentConfig.depth = Math.min(this.currentConfig.depth + 1, 10);
+            this.currentConfig.reflectionEnabled = true;
+            this.currentConfig.planningIterations = Math.min(this.currentConfig.planningIterations + 1, 5);
+        }
+        else if (successRate > 0.9 && avgLatency > 5000) {
+            // High success but slow - reduce depth for speed
+            this.currentConfig.depth = Math.max(this.currentConfig.depth - 1, 1);
+            this.currentConfig.planningIterations = Math.max(this.currentConfig.planningIterations - 1, 1);
+        }
+        // Record optimization
+        await this.metricsCollector.record({
+            name: 'reasoning.optimization',
+            value: this.currentConfig.depth,
+            tags: {
+                depth: String(this.currentConfig.depth),
+                chainOfThought: String(this.currentConfig.useChainOfThought),
+            },
+        });
+        return { ...this.currentConfig };
+    }
+    /**
+     * Get current reasoning config
+     */
+    getConfig() {
+        return { ...this.currentConfig };
+    }
+    /**
+     * Set reasoning config
+     */
+    setConfig(config) {
+        this.currentConfig = { ...this.currentConfig, ...config };
+    }
+    /**
+     * Get agent ID
+     */
+    getId() {
+        return 'reasoning-optimizer-agent';
+    }
+}