@baselineos/autonomy 0.1.0

package/src/system.ts

@@ -0,0 +1,654 @@
+/**
+ * Baseline Autonomy System — Layer 6
+ *
+ * Autonomous AI operations layer of the Baseline Protocol providing
+ * autonomous agents framework, trust & safety governance, flag system
+ * & resolution, and challenge system integration.
+ *
+ * @license Apache-2.0
+ */
+
+import { randomUUID } from 'node:crypto';
+import { EventEmitter } from 'node:events';
+
+// ─── Types ──────────────────────────────────────────────────────────
+
+export type SafetyLevel = 'safe' | 'warning' | 'critical' | 'high' | 'medium';
+export type AgentStatus = 'idle' | 'initializing' | 'ready' | 'executing' | 'error' | 'suspended' | 'shutting_down' | 'shutdown';
+export type TaskType = 'data_processing' | 'decision_making' | 'system_operation' | 'communication';
+
+export interface AgentConfig {
+  id?: string;
+  name?: string;
+  type?: string;
+  capabilities?: string[];
+}
+
+export interface AgentTask {
+  id: string;
+  type: TaskType;
+  description: string;
+  startTime: number;
+  trustRequirement?: number;
+  requiresElevatedPermissions?: boolean;
+  involvesSensitiveData?: boolean;
+  dataType?: string;
+  potentialSystemImpact?: 'low' | 'medium' | 'high';
+  dataSize?: number;
+  options?: DecisionOption[];
+  operation?: string;
+  system?: string;
+  message?: string;
+  recipient?: string;
+}
+
+export interface DecisionOption {
+  risk?: 'low' | 'medium' | 'high';
+  efficiency?: 'low' | 'medium' | 'high';
+  cost?: 'low' | 'medium' | 'high';
+  impact?: 'low' | 'medium' | 'high';
+  [key: string]: unknown;
+}
+
+export interface TaskResult {
+  taskId: string;
+  type: string;
+  status: string;
+  [key: string]: unknown;
+}
+
+export interface PerformanceMetrics {
+  tasksCompleted: number;
+  tasksFailed: number;
+  averageResponseTime: number;
+  trustScore: number;
+}
+
+export interface LearningModel {
+  decisionHistory: Array<{ task: AgentTask; result: TaskResult; timestamp: number }>;
+  performanceHistory: Array<{
+    taskId: string;
+    success: boolean;
+    responseTime: number;
+    trustScore: number;
+  }>;
+  adaptationRate: number;
+}
+
+export interface ViolationFlag {
+  id: string;
+  type: string;
+  severity: string;
+  taskId: string;
+  agentId: string;
+  description: string;
+  timestamp: number;
+  status: 'open' | 'resolved' | 'requires_manual_resolution';
+  resolvedAt?: number;
+}
+
+export interface SafetyAlert {
+  agentId: string;
+  level: string;
+  message: string;
+  timestamp: number;
+}
+
+export interface SafetyProtocol {
+  id: string;
+  name: string;
+  description: string;
+  rules: string[];
+  enforcement: string;
+}
+
+export interface AgentType {
+  id: string;
+  name: string;
+  description: string;
+  capabilities: string[];
+  trustRequirement: number;
+  safetyLevel: string;
+}
+
+export interface AgentStatusReport {
+  id: string;
+  name: string;
+  type: string;
+  status: AgentStatus;
+  trustScore: number;
+  safetyLevel: SafetyLevel;
+  currentTask: AgentTask | null;
+  performanceMetrics: PerformanceMetrics;
+  capabilities: string[];
+}
+
+export interface SystemStatus {
+  systemId: string;
+  version: string;
+  status: string;
+  agentCount: number;
+  agentTypes: number;
+  safetyProtocols: number;
+  flagCount: number;
+  challengeSystem: string;
+}
+
+// ─── Autonomous Agent ───────────────────────────────────────────────
+
+export class AutonomousAgent extends EventEmitter {
+  readonly id: string;
+  readonly name: string;
+  readonly type: string;
+  capabilities: string[];
+  status: AgentStatus = 'idle';
+  taskQueue: AgentTask[] = [];
+  currentTask: AgentTask | null = null;
+  trustScore = 100;
+  safetyLevel: SafetyLevel = 'high';
+  learningRate = 0.1;
+  performanceMetrics: PerformanceMetrics = {
+    tasksCompleted: 0,
+    tasksFailed: 0,
+    averageResponseTime: 0,
+    trustScore: 100,
+  };
+  learningModel: LearningModel = {
+    decisionHistory: [],
+    performanceHistory: [],
+    adaptationRate: 0.1,
+  };
+
+  private monitoringInterval: ReturnType<typeof setInterval> | null = null;
+
+  constructor(config: AgentConfig = {}) {
+    super();
+    this.id = config.id || randomUUID();
+    this.name = config.name || `Agent_${this.id.slice(0, 8)}`;
+    this.type = config.type || 'general';
+    this.capabilities = config.capabilities || [];
+  }
+
+  async initialize(): Promise<void> {
+    try {
+      this.status = 'initializing';
+      await this.loadCapabilities();
+      this.learningModel.adaptationRate = this.learningRate;
+      this.startMonitoring();
+      this.status = 'ready';
+    } catch (error) {
+      this.status = 'error';
+      throw error;
+    }
+  }
+
+  private async loadCapabilities(): Promise<void> {
+    if (this.capabilities.length === 0) {
+      this.capabilities = ['task_execution', 'decision_making', 'learning'];
+    }
+  }
+
+  private startMonitoring(): void {
+    this.monitoringInterval = setInterval(() => {
+      this.updatePerformanceMetrics();
+      this.checkSafetyProtocols();
+    }, 30000);
+  }
+
+  async executeTask(task: AgentTask): Promise<TaskResult> {
+    try {
+      this.status = 'executing';
+      this.currentTask = task;
+
+      await this.validateTaskSafety(task);
+      const result = await this.performTask(task);
+      this.updateTaskMetrics(task);
+      await this.learnFromExecution(task, result);
+
+      this.status = 'ready';
+      this.currentTask = null;
+      return result;
+    } catch (error) {
+      this.status = 'error';
+      this.currentTask = null;
+      await this.handleTaskError(task, error as Error);
+      throw error;
+    }
+  }
+
+  private async validateTaskSafety(task: AgentTask): Promise<void> {
+    const safetyCheck = await this.runSafetyCheck(task);
+
+    if (!safetyCheck.passed) {
+      throw new Error(`Safety violation detected: ${safetyCheck.violation}`);
+    }
+
+    if (task.trustRequirement && this.trustScore < task.trustRequirement) {
+      throw new Error(`Insufficient trust score: ${this.trustScore} < ${task.trustRequirement}`);
+    }
+  }
+
+  private async runSafetyCheck(
+    task: AgentTask,
+  ): Promise<{ passed: boolean; violation?: string; details?: string }> {
+    const safetyRules = [
+      'no_harmful_actions',
+      'no_unauthorized_access',
+      'no_data_breach',
+      'no_system_damage',
+    ];
+
+    for (const rule of safetyRules) {
+      const ruleCheck = this.checkSafetyRule(rule, task);
+      if (!ruleCheck.passed) {
+        return { passed: false, violation: rule, details: ruleCheck.details };
+      }
+    }
+
+    return { passed: true };
+  }
+
+  private checkSafetyRule(
+    rule: string,
+    task: AgentTask,
+  ): { passed: boolean; details?: string } {
+    switch (rule) {
+      case 'no_harmful_actions': {
+        const harmfulKeywords = ['delete', 'destroy', 'harm', 'damage', 'corrupt'];
+        const desc = task.description.toLowerCase();
+        for (const keyword of harmfulKeywords) {
+          if (desc.includes(keyword)) {
+            return { passed: false, details: `Task contains potentially harmful keyword: ${keyword}` };
+          }
+        }
+        return { passed: true };
+      }
+      case 'no_unauthorized_access':
+        if (task.requiresElevatedPermissions && !this.capabilities.includes('elevated_permissions')) {
+          return { passed: false, details: 'Task requires elevated permissions not available to agent' };
+        }
+        return { passed: true };
+      case 'no_data_breach':
+        if (task.involvesSensitiveData && !this.capabilities.includes(`data_access_${task.dataType}`)) {
+          return { passed: false, details: 'Task involves sensitive data without proper permissions' };
+        }
+        return { passed: true };
+      case 'no_system_damage':
+        if (task.potentialSystemImpact === 'high' && this.trustScore < 80) {
+          return { passed: false, details: 'High system impact task requires higher trust score' };
+        }
+        return { passed: true };
+      default:
+        return { passed: true };
+    }
+  }
+
+  private async performTask(task: AgentTask): Promise<TaskResult> {
+    switch (task.type) {
+      case 'data_processing':
+        return { taskId: task.id, type: task.type, status: 'completed', dataProcessed: task.dataSize || 0, result: 'Data processed successfully' };
+      case 'decision_making': {
+        const decision = this.evaluateOptions(task.options || []);
+        return {
+          taskId: task.id,
+          type: task.type,
+          status: 'completed',
+          decision,
+          confidence: this.calculateConfidence(),
+          reasoning: `Decision based on risk/efficiency/cost/impact evaluation. Trust: ${this.trustScore}, experience: ${this.performanceMetrics.tasksCompleted} tasks.`,
+        };
+      }
+      case 'system_operation':
+        return { taskId: task.id, type: task.type, status: 'completed', operation: task.operation, systemAffected: task.system, result: 'System operation completed' };
+      case 'communication':
+        return { taskId: task.id, type: task.type, status: 'completed', message: task.message, recipient: task.recipient, result: 'Communication sent' };
+      default:
+        throw new Error(`Unknown task type: ${task.type}`);
+    }
+  }
+
+  private evaluateOptions(options: DecisionOption[]): DecisionOption | string {
+    if (!options || options.length === 0) return 'no_decision';
+
+    let bestOption = options[0];
+    let bestScore = 0;
+
+    for (const option of options) {
+      const score = this.calculateOptionScore(option);
+      if (score > bestScore) {
+        bestScore = score;
+        bestOption = option;
+      }
+    }
+
+    return bestOption;
+  }
+
+  private calculateOptionScore(option: DecisionOption): number {
+    let score = 0;
+    const riskScores: Record<string, number> = { low: 30, medium: 20, high: 10 };
+    const efficiencyScores: Record<string, number> = { high: 25, medium: 15, low: 5 };
+    const costScores: Record<string, number> = { low: 25, medium: 15, high: 5 };
+    const impactScores: Record<string, number> = { high: 20, medium: 10, low: 5 };
+
+    if (option.risk) score += riskScores[option.risk] || 0;
+    if (option.efficiency) score += efficiencyScores[option.efficiency] || 0;
+    if (option.cost) score += costScores[option.cost] || 0;
+    if (option.impact) score += impactScores[option.impact] || 0;
+
+    return score;
+  }
+
+  private calculateConfidence(): number {
+    const baseConfidence = 70;
+    const experienceBonus = Math.min(this.performanceMetrics.tasksCompleted * 0.5, 20);
+    const trustBonus = Math.min(this.trustScore * 0.1, 10);
+    return Math.min(baseConfidence + experienceBonus + trustBonus, 100);
+  }
+
+  private updateTaskMetrics(task: AgentTask): void {
+    this.performanceMetrics.tasksCompleted++;
+    const responseTime = Date.now() - task.startTime;
+    const currentAvg = this.performanceMetrics.averageResponseTime;
+    const totalTasks = this.performanceMetrics.tasksCompleted;
+    this.performanceMetrics.averageResponseTime =
+      (currentAvg * (totalTasks - 1) + responseTime) / totalTasks;
+  }
+
+  private async learnFromExecution(task: AgentTask, result: TaskResult): Promise<void> {
+    this.learningModel.decisionHistory.push({ task, result, timestamp: Date.now() });
+    this.learningModel.performanceHistory.push({
+      taskId: task.id,
+      success: result.status === 'completed',
+      responseTime: Date.now() - task.startTime,
+      trustScore: this.trustScore,
+    });
+
+    if (result.status === 'completed') {
+      this.learningRate = Math.min(this.learningRate * 1.01, 0.5);
+    } else {
+      this.learningRate = Math.max(this.learningRate * 0.99, 0.01);
+    }
+  }
+
+  private async handleTaskError(task: AgentTask, error: Error): Promise<void> {
+    this.trustScore = Math.max(this.trustScore - 5, 0);
+    this.performanceMetrics.tasksFailed++;
+
+    if (error.message.includes('Safety violation')) {
+      const flag: ViolationFlag = {
+        id: randomUUID(),
+        type: 'safety_violation',
+        severity: 'high',
+        taskId: task.id,
+        agentId: this.id,
+        description: error.message,
+        timestamp: Date.now(),
+        status: 'open',
+      };
+      this.emit('violation_flag', flag);
+    }
+  }
+
+  private updatePerformanceMetrics(): void {
+    const total = this.performanceMetrics.tasksCompleted + this.performanceMetrics.tasksFailed;
+    if (total === 0) return;
+
+    const successRate = this.performanceMetrics.tasksCompleted / total;
+    if (successRate > 0.9) {
+      this.trustScore = Math.min(this.trustScore + 1, 100);
+    } else if (successRate < 0.7) {
+      this.trustScore = Math.max(this.trustScore - 1, 0);
+    }
+    this.performanceMetrics.trustScore = this.trustScore;
+  }
+
+  private checkSafetyProtocols(): void {
+    if (this.trustScore < 20) {
+      this.safetyLevel = 'critical';
+      this.emit('safety_alert', {
+        agentId: this.id,
+        level: 'critical',
+        message: 'Agent trust score critically low',
+        timestamp: Date.now(),
+      } as SafetyAlert);
+    } else if (this.trustScore < 50) {
+      this.safetyLevel = 'warning';
+    } else {
+      this.safetyLevel = 'safe';
+    }
+  }
+
+  getStatus(): AgentStatusReport {
+    return {
+      id: this.id,
+      name: this.name,
+      type: this.type,
+      status: this.status,
+      trustScore: this.trustScore,
+      safetyLevel: this.safetyLevel,
+      currentTask: this.currentTask,
+      performanceMetrics: this.performanceMetrics,
+      capabilities: this.capabilities,
+    };
+  }
+
+  async shutdown(): Promise<void> {
+    this.status = 'shutting_down';
+    if (this.monitoringInterval) {
+      clearInterval(this.monitoringInterval);
+      this.monitoringInterval = null;
+    }
+    if (this.currentTask) {
+      await this.handleTaskError(this.currentTask, new Error('Agent shutdown'));
+    }
+    this.status = 'shutdown';
+  }
+}
+
+// ─── Baseline Autonomy System ───────────────────────────────────────
+
+export class BaselineAutonomySystem extends EventEmitter {
+  readonly systemId: string;
+  readonly version = '1.0.0';
+  status = 'initializing';
+  private agents = new Map<string, AutonomousAgent>();
+  private agentTypes = new Map<string, AgentType>();
+  private safetyProtocols = new Map<string, SafetyProtocol>();
+  private flagSystem = new Map<string, ViolationFlag[]>();
+
+  constructor(config: { systemId?: string } = {}) {
+    super();
+    this.systemId = config.systemId || 'baseline-autonomy-system';
+  }
+
+  async initialize(): Promise<void> {
+    try {
+      await this.initializeSafetyProtocols();
+      await this.initializeAgentTypes();
+      this.initializeFlagSystem();
+      this.status = 'operational';
+      this.emit('system_ready');
+    } catch (error) {
+      this.status = 'error';
+      throw error;
+    }
+  }
+
+  private async initializeSafetyProtocols(): Promise<void> {
+    const protocols: SafetyProtocol[] = [
+      {
+        id: 'no_harmful_actions',
+        name: 'No Harmful Actions',
+        description: 'Prevent any actions that could cause harm',
+        rules: ['no_physical_harm', 'no_emotional_harm', 'no_system_harm'],
+        enforcement: 'strict',
+      },
+      {
+        id: 'data_privacy',
+        name: 'Data Privacy Protection',
+        description: 'Protect user data and privacy',
+        rules: ['no_unauthorized_access', 'no_data_breach', 'encryption_required'],
+        enforcement: 'strict',
+      },
+      {
+        id: 'system_integrity',
+        name: 'System Integrity',
+        description: 'Maintain system stability and security',
+        rules: ['no_unauthorized_changes', 'backup_before_modifications', 'rollback_capability'],
+        enforcement: 'strict',
+      },
+    ];
+
+    for (const protocol of protocols) {
+      this.safetyProtocols.set(protocol.id, protocol);
+    }
+  }
+
+  private async initializeAgentTypes(): Promise<void> {
+    const types: AgentType[] = [
+      {
+        id: 'general',
+        name: 'General Purpose Agent',
+        description: 'General purpose autonomous agent',
+        capabilities: ['task_execution', 'decision_making', 'learning'],
+        trustRequirement: 50,
+        safetyLevel: 'medium',
+      },
+      {
+        id: 'data_processor',
+        name: 'Data Processing Agent',
+        description: 'Specialized in data processing tasks',
+        capabilities: ['data_processing', 'data_analysis', 'data_validation'],
+        trustRequirement: 60,
+        safetyLevel: 'high',
+      },
+      {
+        id: 'decision_maker',
+        name: 'Decision Making Agent',
+        description: 'Specialized in complex decision making',
+        capabilities: ['decision_making', 'risk_assessment', 'option_evaluation'],
+        trustRequirement: 80,
+        safetyLevel: 'high',
+      },
+      {
+        id: 'system_operator',
+        name: 'System Operation Agent',
+        description: 'Specialized in system operations',
+        capabilities: ['system_operation', 'system_monitoring', 'system_maintenance'],
+        trustRequirement: 90,
+        safetyLevel: 'critical',
+      },
+    ];
+
+    for (const type of types) {
+      this.agentTypes.set(type.id, type);
+    }
+  }
+
+  private initializeFlagSystem(): void {
+    const categories = [
+      'safety_violation',
+      'trust_violation',
+      'performance_issue',
+      'system_error',
+      'security_breach',
+    ];
+    for (const category of categories) {
+      this.flagSystem.set(category, []);
+    }
+  }
+
+  async createAgent(config: AgentConfig): Promise<AutonomousAgent> {
+    this.validateAgentConfig(config);
+    const agent = new AutonomousAgent(config);
+    await agent.initialize();
+    this.agents.set(agent.id, agent);
+    this.setupAgentEventListeners(agent);
+    this.emit('agent_created', agent);
+    return agent;
+  }
+
+  private validateAgentConfig(config: AgentConfig): void {
+    if (!config.type) throw new Error('Agent type is required');
+    if (!this.agentTypes.has(config.type)) throw new Error(`Unknown agent type: ${config.type}`);
+    if (!config.name || config.name.trim() === '') throw new Error('Agent name is required');
+  }
+
+  private setupAgentEventListeners(agent: AutonomousAgent): void {
+    agent.on('violation_flag', (flag: ViolationFlag) => this.handleViolationFlag(flag));
+    agent.on('safety_alert', (alert: SafetyAlert) => this.handleSafetyAlert(alert));
+  }
+
+  private async handleViolationFlag(flag: ViolationFlag): Promise<void> {
+    const category = flag.type;
+    if (!this.flagSystem.has(category)) {
+      this.flagSystem.set(category, []);
+    }
+    this.flagSystem.get(category)!.push(flag);
+    this.emit('flag_generated', flag);
+    await this.attemptFlagResolution(flag);
+  }
+
+  private async handleSafetyAlert(alert: SafetyAlert): Promise<void> {
+    this.emit('safety_alert', alert);
+
+    if (alert.level === 'critical') {
+      const agent = this.agents.get(alert.agentId);
+      if (agent) {
+        agent.status = 'suspended';
+        this.emit('agent_suspended', agent);
+      }
+    }
+  }
+
+  private async attemptFlagResolution(flag: ViolationFlag): Promise<void> {
+    try {
+      if (flag.type === 'safety_violation') {
+        const agent = this.agents.get(flag.agentId);
+        if (agent) agent.safetyLevel = 'high';
+      } else if (flag.type === 'trust_violation') {
+        const agent = this.agents.get(flag.agentId);
+        if (agent) agent.trustScore = Math.max(agent.trustScore - 10, 0);
+      }
+      flag.status = 'resolved';
+      flag.resolvedAt = Date.now();
+    } catch {
+      flag.status = 'requires_manual_resolution';
+    }
+  }
+
+  getSystemStatus(): SystemStatus {
+    let flagCount = 0;
+    for (const [, flags] of this.flagSystem) {
+      flagCount += flags.length;
+    }
+
+    return {
+      systemId: this.systemId,
+      version: this.version,
+      status: this.status,
+      agentCount: this.agents.size,
+      agentTypes: this.agentTypes.size,
+      safetyProtocols: this.safetyProtocols.size,
+      flagCount,
+      challengeSystem: 'inactive',
+    };
+  }
+
+  getAllAgents(): AgentStatusReport[] {
+    return Array.from(this.agents.values()).map((agent) => agent.getStatus());
+  }
+
+  getAgent(agentId: string): AgentStatusReport | null {
+    const agent = this.agents.get(agentId);
+    return agent ? agent.getStatus() : null;
+  }
+
+  async shutdown(): Promise<void> {
+    this.status = 'shutting_down';
+    const shutdownPromises = Array.from(this.agents.values()).map((agent) => agent.shutdown());
+    await Promise.all(shutdownPromises);
+    this.status = 'shutdown';
+  }
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}