@baselineos/autonomy 0.1.0

package/.turbo/turbo-build.log

@@ -0,0 +1,14 @@
+
+> @baselineos/autonomy@0.1.0 build /home/runner/work/baseline/baseline/packages/autonomy
+> tsup src/index.ts --format esm --dts
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Target: es2022
+ESM Build start
+ESM dist/index.js 89.50 KB
+ESM ⚡️ Build success in 210ms
+DTS Build start
+DTS ⚡️ Build success in 16026ms
+DTS dist/index.d.ts 15.84 KB

package/.turbo/turbo-test.log

@@ -0,0 +1,14 @@
+
+> @baselineos/autonomy@0.1.0 test /home/runner/work/baseline/baseline/packages/autonomy
+> vitest run
+
+
+ RUN  v2.1.9 /home/runner/work/baseline/baseline/packages/autonomy
+
+ ✓ src/__tests__/smoke.test.ts (2 tests) 17ms
+
+ Test Files  1 passed (1)
+      Tests  2 passed (2)
+   Start at  14:02:30
+   Duration  3.80s (transform 1.79s, setup 0ms, collect 2.03s, tests 17ms, environment 0ms, prepare 706ms)
+

package/LICENSE

@@ -0,0 +1,17 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+Copyright 2026 Baseline Protocol Foundation
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,19 @@
+# @baselineos/autonomy
+
+Autonomy layer package for Baseline.
+
+## Purpose
+
+Implements agent autonomy runtime behavior and contracts used by `baselineos` and the CLI orchestration flow.
+
+## Commands
+
+```bash
+pnpm --filter @baselineos/autonomy build
+pnpm --filter @baselineos/autonomy test
+```
+
+## Integration
+
+- Depends on: `@baselineos/protocol-core`
+- Consumed by: `@baselineos/cli`, `baselineos`

package/dist/index.d.ts

@@ -0,0 +1,539 @@
+import { EventEmitter } from 'node:events';
+import { EventEmitter as EventEmitter$1 } from 'events';
+
+/**
+ * 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
+ */
+
+type SafetyLevel = 'safe' | 'warning' | 'critical' | 'high' | 'medium';
+type AgentStatus = 'idle' | 'initializing' | 'ready' | 'executing' | 'error' | 'suspended' | 'shutting_down' | 'shutdown';
+type TaskType = 'data_processing' | 'decision_making' | 'system_operation' | 'communication';
+interface AgentConfig {
+    id?: string;
+    name?: string;
+    type?: string;
+    capabilities?: string[];
+}
+interface AgentTask$1 {
+    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;
+}
+interface DecisionOption {
+    risk?: 'low' | 'medium' | 'high';
+    efficiency?: 'low' | 'medium' | 'high';
+    cost?: 'low' | 'medium' | 'high';
+    impact?: 'low' | 'medium' | 'high';
+    [key: string]: unknown;
+}
+interface TaskResult$1 {
+    taskId: string;
+    type: string;
+    status: string;
+    [key: string]: unknown;
+}
+interface PerformanceMetrics {
+    tasksCompleted: number;
+    tasksFailed: number;
+    averageResponseTime: number;
+    trustScore: number;
+}
+interface LearningModel {
+    decisionHistory: Array<{
+        task: AgentTask$1;
+        result: TaskResult$1;
+        timestamp: number;
+    }>;
+    performanceHistory: Array<{
+        taskId: string;
+        success: boolean;
+        responseTime: number;
+        trustScore: number;
+    }>;
+    adaptationRate: number;
+}
+interface ViolationFlag {
+    id: string;
+    type: string;
+    severity: string;
+    taskId: string;
+    agentId: string;
+    description: string;
+    timestamp: number;
+    status: 'open' | 'resolved' | 'requires_manual_resolution';
+    resolvedAt?: number;
+}
+interface SafetyAlert {
+    agentId: string;
+    level: string;
+    message: string;
+    timestamp: number;
+}
+interface SafetyProtocol$1 {
+    id: string;
+    name: string;
+    description: string;
+    rules: string[];
+    enforcement: string;
+}
+interface AgentType {
+    id: string;
+    name: string;
+    description: string;
+    capabilities: string[];
+    trustRequirement: number;
+    safetyLevel: string;
+}
+interface AgentStatusReport {
+    id: string;
+    name: string;
+    type: string;
+    status: AgentStatus;
+    trustScore: number;
+    safetyLevel: SafetyLevel;
+    currentTask: AgentTask$1 | null;
+    performanceMetrics: PerformanceMetrics;
+    capabilities: string[];
+}
+interface SystemStatus {
+    systemId: string;
+    version: string;
+    status: string;
+    agentCount: number;
+    agentTypes: number;
+    safetyProtocols: number;
+    flagCount: number;
+    challengeSystem: string;
+}
+declare class AutonomousAgent extends EventEmitter {
+    readonly id: string;
+    readonly name: string;
+    readonly type: string;
+    capabilities: string[];
+    status: AgentStatus;
+    taskQueue: AgentTask$1[];
+    currentTask: AgentTask$1 | null;
+    trustScore: number;
+    safetyLevel: SafetyLevel;
+    learningRate: number;
+    performanceMetrics: PerformanceMetrics;
+    learningModel: LearningModel;
+    private monitoringInterval;
+    constructor(config?: AgentConfig);
+    initialize(): Promise<void>;
+    private loadCapabilities;
+    private startMonitoring;
+    executeTask(task: AgentTask$1): Promise<TaskResult$1>;
+    private validateTaskSafety;
+    private runSafetyCheck;
+    private checkSafetyRule;
+    private performTask;
+    private evaluateOptions;
+    private calculateOptionScore;
+    private calculateConfidence;
+    private updateTaskMetrics;
+    private learnFromExecution;
+    private handleTaskError;
+    private updatePerformanceMetrics;
+    private checkSafetyProtocols;
+    getStatus(): AgentStatusReport;
+    shutdown(): Promise<void>;
+}
+declare class BaselineAutonomySystem extends EventEmitter {
+    readonly systemId: string;
+    readonly version = "1.0.0";
+    status: string;
+    private agents;
+    private agentTypes;
+    private safetyProtocols;
+    private flagSystem;
+    constructor(config?: {
+        systemId?: string;
+    });
+    initialize(): Promise<void>;
+    private initializeSafetyProtocols;
+    private initializeAgentTypes;
+    private initializeFlagSystem;
+    createAgent(config: AgentConfig): Promise<AutonomousAgent>;
+    private validateAgentConfig;
+    private setupAgentEventListeners;
+    private handleViolationFlag;
+    private handleSafetyAlert;
+    private attemptFlagResolution;
+    getSystemStatus(): SystemStatus;
+    getAllAgents(): AgentStatusReport[];
+    getAgent(agentId: string): AgentStatusReport | null;
+    shutdown(): Promise<void>;
+}
+
+interface LifecycleStage {
+    id: string;
+    name: string;
+    description: string;
+    order: number;
+    required: boolean;
+    autoTransition: boolean;
+}
+interface StageHistoryEntry {
+    stage: string;
+    timestamp: number;
+    status: string;
+    error?: string;
+}
+interface AgentDeployment {
+    agentId: string;
+    agentName: string;
+    currentStage: string;
+    stageHistory: StageHistoryEntry[];
+    startTime: number;
+    status: string;
+    metrics: {
+        stageTransitions: number;
+        totalTime: number;
+        errors: number;
+    };
+}
+interface ScalingPolicy {
+    id: string;
+    name: string;
+    description: string;
+    triggers: string[];
+    actions: string[];
+    thresholds: Record<string, number>;
+}
+interface RetirementPolicy {
+    id: string;
+    name: string;
+    description: string;
+    criteria: string[];
+    thresholds: Record<string, number>;
+    gracePeriod: number;
+}
+interface HealthMonitor {
+    id: string;
+    name: string;
+    metrics: string[];
+    interval: number;
+    thresholds: Record<string, number | string>;
+}
+interface ThresholdViolation {
+    metric: string;
+    value: number;
+    threshold: number | string;
+    severity: string;
+}
+interface LifecycleStatus {
+    agentId: string;
+    agentName: string;
+    currentStage: string;
+    status: string;
+    stageHistory: StageHistoryEntry[];
+    metrics: AgentDeployment['metrics'];
+    uptime: number;
+}
+interface Alert {
+    id: string;
+    type: string;
+    severity: string;
+    message: string;
+    agentId: string;
+    timestamp: number;
+    violations: ThresholdViolation[];
+}
+declare class AgentLifecycleManager extends EventEmitter$1 {
+    private autonomySystem;
+    private lifecycleStages;
+    private agentDeployments;
+    private scalingPolicies;
+    private retirementPolicies;
+    private healthMonitors;
+    constructor(autonomySystem: unknown);
+    initialize(): Promise<void>;
+    private initializeLifecycleStages;
+    private initializeScalingPolicies;
+    private initializeRetirementPolicies;
+    private initializeHealthMonitoring;
+    createAndDeployAgent(agentName: string, agentConfig?: Record<string, unknown>): Promise<AgentDeployment>;
+    private initializeAgentLifecycle;
+    private executeLifecycleStages;
+    private executeStage;
+    private executeCreationStage;
+    private executeValidationStage;
+    private executeDeploymentStage;
+    private executeActivationStage;
+    private executeMonitoringStage;
+    private executeScalingStage;
+    private executeMaintenanceStage;
+    private executeRetirementStage;
+    private simulateDeployment;
+    private startAutonomousOperations;
+    private startComprehensiveMonitoring;
+    private startHealthMonitor;
+    private collectMetrics;
+    private checkThresholdViolations;
+    private calculateViolationSeverity;
+    private handleThresholdViolations;
+    private handleCriticalViolation;
+    private handleHighViolation;
+    private handleLowViolation;
+    private generateAlert;
+    private increaseMonitoringFrequency;
+    private checkScalingNeeded;
+    private evaluateScalingPolicy;
+    private executeScaling;
+    private checkMaintenanceNeeded;
+    private executeMaintenance;
+    private checkRetirementNeeded;
+    private evaluateRetirementPolicy;
+    private executeRetirement;
+    getLifecycleStatus(agentId: string): LifecycleStatus | null;
+    getAllLifecycleStatuses(): LifecycleStatus[];
+    private delay;
+}
+
+type MigrationMode = 'parallel' | 'progressive' | 'full';
+interface IntegrationPoint {
+    layer: string;
+    purpose: string;
+    integration: string;
+    status: string;
+}
+interface MigrationComponentStatus {
+    component: string;
+    currentStatus: string;
+    targetStatus: string;
+    migrationProgress: number;
+    dependencies: string[];
+    estimatedCompletion: string;
+}
+interface ComparisonResult {
+    timestamp: Date;
+    legacyResult: string;
+    newResult: string;
+    quality: Record<string, unknown>;
+    performance: Record<string, unknown>;
+    recommendation: string | null;
+}
+interface IntegrationStatus {
+    migrationMode: MigrationMode;
+    integrationPoints: IntegrationPoint[];
+    migrationStatus: MigrationComponentStatus[];
+    comparisonHistory: ComparisonResult[];
+    statistics: {
+        totalComparisons: number;
+        averageQualityImprovement: number;
+        averagePerformanceImprovement: number;
+        recommendationsForNew: number;
+        recommendationsForLegacy: number;
+    };
+}
+interface MigrationRecommendation {
+    component: string;
+    currentStatus: string;
+    recommendation: string;
+    priority: number;
+    reason: string;
+}
+declare class BaselineAutonomyIntegration extends EventEmitter$1 {
+    private migrationMode;
+    private integrationPoints;
+    private migrationStatus;
+    private comparisonHistory;
+    private autonomySystem;
+    constructor(autonomySystem: unknown);
+    initialize(): Promise<void>;
+    private initializeIntegrationPoints;
+    private initializeMigrationStatus;
+    executeCommand(command: string, context?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    private executeParallel;
+    private executeProgressive;
+    private executeNew;
+    private executeLegacy;
+    private compareResults;
+    private assessQuality;
+    private calculateImprovement;
+    private generateRecommendation;
+    private validateResult;
+    getIntegrationStatus(): IntegrationStatus;
+    setMigrationMode(mode: MigrationMode): void;
+    getMigrationRecommendations(): MigrationRecommendation[];
+    private calculatePriority;
+    private findRelevantComponent;
+    private delay;
+}
+
+interface SafetyProtocol {
+    enabled: boolean;
+    level: string;
+    rules: string[];
+}
+interface SafetyCheckResult {
+    protocol: string;
+    timestamp: Date;
+    status: string;
+    violations: unknown[];
+    details: Record<string, unknown>;
+}
+interface SafetyMonitoringResult {
+    timestamp: Date;
+    trustScore: number;
+    safetyChecks: SafetyCheckResult[];
+    violations: unknown[];
+    recommendations: unknown[];
+}
+interface MastraAgentPerformanceMetrics {
+    tasksCompleted: number;
+    tasksFailed: number;
+    averageResponseTime: number;
+    trustScore: number;
+}
+interface AgentTask {
+    id: string;
+    type: string;
+    description: string;
+    input: Record<string, unknown>;
+    priority: number;
+    timeout: number;
+}
+interface TaskResult {
+    taskId: string;
+    agentId: string;
+    status: string;
+    output: unknown;
+    reasoning: string;
+    confidence: number;
+    executionTime: number;
+    timestamp: Date;
+}
+interface ReasoningStep {
+    step: number;
+    action: string;
+    reasoning: string;
+    confidence: number;
+    timestamp: Date;
+}
+interface ReasoningResult {
+    agentId: string;
+    task: string;
+    steps: ReasoningStep[];
+    finalDecision: string;
+    confidence: number;
+    timestamp: Date;
+}
+interface CoordinationPlan {
+    coordinatorId: string;
+    taskId: string;
+    participants: string[];
+    steps: CoordinationStep[];
+    timestamp: Date;
+}
+interface CoordinationStep {
+    step: number;
+    agentId: string;
+    action: string;
+    status: string;
+}
+interface CoordinationResult {
+    plan: CoordinationPlan;
+    results: TaskResult[];
+    overallStatus: string;
+    timestamp: Date;
+}
+interface EngineStatus {
+    engineId: string;
+    version: string;
+    status: string;
+    capabilities: string[];
+    agentCount: number;
+    trustScore: number;
+    learningRate: number;
+    memorySize: number;
+    safetyProtocols: string[];
+}
+interface AgentInfo {
+    id: string;
+    name: string;
+    type: string;
+    capabilities: string[];
+    status: string;
+    trustScore: number;
+    performance: MastraAgentPerformanceMetrics;
+    taskHistory: TaskResult[];
+}
+declare class MastraAutonomyEngine extends EventEmitter$1 {
+    engineId: string;
+    version: string;
+    status: string;
+    capabilities: Set<string>;
+    agents: Map<string, MastraAutonomousAgent>;
+    memory: Map<string, unknown>;
+    safetyProtocols: Map<string, SafetyProtocol>;
+    trustScore: number;
+    learningRate: number;
+    private llm;
+    private globalMemory;
+    constructor();
+    initialize(): Promise<void>;
+    private initializeLLM;
+    private initializeMemory;
+    private initializeSafetyProtocols;
+    private initializeCapabilities;
+    createAutonomousAgent(name: string, type: string, capabilities: string[]): Promise<MastraAutonomousAgent>;
+    executeAutonomousReasoning(agentId: string, task: string, context?: Record<string, unknown>): Promise<ReasoningResult>;
+    executeAutonomousTask(agentId: string, task: AgentTask): Promise<TaskResult>;
+    coordinateAgents(agentIds: string[], task: AgentTask): Promise<CoordinationResult>;
+    private createCoordinationPlan;
+    monitorTrustAndSafety(): Promise<SafetyMonitoringResult>;
+    runSafetyCheck(protocolId: string, context: string): Promise<SafetyCheckResult>;
+    private checkContentSafety;
+    private validateTrust;
+    private checkAutonomyLimits;
+    private generateSafetyRecommendations;
+    getStatus(): EngineStatus;
+    getCapabilities(): string[];
+    getAgentInfo(agentId: string): AgentInfo | null;
+    getAllAgents(): AgentInfo[];
+    private delay;
+}
+declare class MastraAutonomousAgent {
+    id: string;
+    name: string;
+    type: string;
+    capabilities: string[];
+    status: string;
+    trustScore: number;
+    taskHistory: TaskResult[];
+    private engine;
+    private createdAt;
+    private tasksCompleted;
+    private tasksFailed;
+    private totalResponseTime;
+    private memory;
+    constructor(name: string, type: string, capabilities: string[], engine: MastraAutonomyEngine);
+    executeTask(task: AgentTask): Promise<TaskResult>;
+    private processTaskWithLangChain;
+    createCoordinationPlan(task: AgentTask, collaborators: MastraAutonomousAgent[]): CoordinationPlan;
+    getStatus(): Record<string, unknown>;
+    getPerformanceMetrics(): MastraAgentPerformanceMetrics;
+    private delay;
+}
+
+export { type AgentConfig, type AgentDeployment, type AgentInfo, AgentLifecycleManager, type AgentStatus, type AgentStatusReport, type AgentTask$1 as AgentTask, type AgentType, type Alert, AutonomousAgent, BaselineAutonomyIntegration, BaselineAutonomySystem, type ComparisonResult, type CoordinationPlan, type CoordinationResult, type CoordinationStep, type DecisionOption, type EngineStatus, type HealthMonitor, type IntegrationPoint, type IntegrationStatus, type LearningModel, type LifecycleStage, type LifecycleStatus, type MastraAgentPerformanceMetrics, type AgentTask as MastraAgentTask, MastraAutonomousAgent, MastraAutonomyEngine, type SafetyProtocol as MastraSafetyProtocol, type TaskResult as MastraTaskResult, type MigrationComponentStatus, type MigrationMode, type MigrationRecommendation, type PerformanceMetrics, type ReasoningResult, type ReasoningStep, type RetirementPolicy, type SafetyAlert, type SafetyCheckResult, type SafetyLevel, type SafetyMonitoringResult, type SafetyProtocol$1 as SafetyProtocol, type ScalingPolicy, type StageHistoryEntry, type SystemStatus, type TaskResult$1 as TaskResult, type TaskType, type ThresholdViolation, type ViolationFlag };