@vorionsys/basis 1.0.1 → 1.0.3

package/dist/trust-factors.test.js

@@ -1,179 +0,0 @@
-/**
- * Trust Factors Test Suite
- *
- * Tests 100 simulated agents through the trust scoring system
- * to validate tier placement is correct.
- */
-import { TrustTier, TIER_THRESHOLDS, getTrustTierFromScore, getTierName, calculateTrustScore, } from './trust-factors';
-// All 23 factor codes
-const ALL_FACTOR_CODES = [
-    'CT-COMP', 'CT-REL', 'CT-OBS', 'CT-TRANS', 'CT-ACCT', 'CT-SAFE',
-    'CT-SEC', 'CT-PRIV', 'CT-ID', 'OP-HUMAN', 'OP-ALIGN', 'OP-STEW',
-    'SF-HUM', 'SF-ADAPT', 'SF-LEARN', 'LC-UNCERT', 'LC-HANDOFF',
-    'LC-EMPHUM', 'LC-CAUSAL', 'LC-PATIENT', 'LC-EMP', 'LC-MORAL', 'LC-TRACK'
-];
-// Generate agent with scores targeting a specific score range
-function generateAgentForScoreRange(agentId, targetTier) {
-    const tierRange = TIER_THRESHOLDS[targetTier];
-    // Target the middle of the tier's score range
-    const targetScore = (tierRange.min + tierRange.max) / 2 / 1000; // Convert to 0-1 scale
-    // Generate uniform scores around the target
-    const factorScores = ALL_FACTOR_CODES.map(code => {
-        // Add some variance but stay near target
-        const variance = (Math.random() - 0.5) * 0.1;
-        const score = Math.min(1.0, Math.max(0, targetScore + variance));
-        return {
-            code: code,
-            score,
-            timestamp: new Date(),
-            source: 'measured',
-            confidence: 0.9,
-        };
-    });
-    return {
-        id: agentId,
-        targetTier,
-        factorScores,
-        expectedScoreRange: tierRange,
-    };
-}
-// Generate edge case agent at boundary of tier
-function generateBoundaryAgent(agentId, targetTier, position) {
-    const tierRange = TIER_THRESHOLDS[targetTier];
-    // Target specific boundary score
-    const targetScore = position === 'low'
-        ? (tierRange.min + 10) / 1000 // Just inside lower bound
-        : (tierRange.max - 10) / 1000; // Just inside upper bound
-    const factorScores = ALL_FACTOR_CODES.map(code => {
-        // Very small variance to stay near boundary
-        const variance = (Math.random() - 0.5) * 0.02;
-        const score = Math.min(1.0, Math.max(0, targetScore + variance));
-        return {
-            code: code,
-            score,
-            timestamp: new Date(),
-            source: 'measured',
-            confidence: 0.9,
-        };
-    });
-    return {
-        id: agentId,
-        targetTier,
-        factorScores,
-        expectedScoreRange: tierRange,
-    };
-}
-function runTests() {
-    console.log('='.repeat(80));
-    console.log('BASIS TRUST FACTORS TEST SUITE');
-    console.log('Testing 100 agents across all trust tiers');
-    console.log('='.repeat(80));
-    console.log('');
-    // Print tier thresholds
-    console.log('TIER THRESHOLDS:');
-    console.log('-'.repeat(50));
-    Object.entries(TIER_THRESHOLDS).forEach(([tier, range]) => {
-        const tierNum = parseInt(tier);
-        console.log(`  T${tierNum} ${getTierName(tierNum)}: ${range.min} - ${range.max}`);
-    });
-    console.log('');
-    const results = [];
-    let agentCounter = 0;
-    // Generate 100 test agents distributed across tiers
-    // T0: 12 agents, T1-T6: 13 agents each, T7: 10 agents
-    const tiersToTest = [
-        { tier: TrustTier.T0_SANDBOX, count: 12 },
-        { tier: TrustTier.T1_OBSERVED, count: 13 },
-        { tier: TrustTier.T2_PROVISIONAL, count: 13 },
-        { tier: TrustTier.T3_VERIFIED, count: 13 },
-        { tier: TrustTier.T4_OPERATIONAL, count: 13 },
-        { tier: TrustTier.T5_TRUSTED, count: 13 },
-        { tier: TrustTier.T6_CERTIFIED, count: 13 },
-        { tier: TrustTier.T7_AUTONOMOUS, count: 10 },
-    ];
-    for (const { tier, count } of tiersToTest) {
-        console.log(`\nTesting T${tier} ${getTierName(tier)} (${count} agents):`);
-        console.log('-'.repeat(60));
-        for (let i = 0; i < count; i++) {
-            agentCounter++;
-            const agentId = `AGENT-${agentCounter.toString().padStart(3, '0')}`;
-            // Mix of regular and boundary agents
-            const agent = i < 2
-                ? generateBoundaryAgent(agentId, tier, i === 0 ? 'low' : 'high')
-                : generateAgentForScoreRange(agentId, tier);
-            // Calculate trust score
-            const evaluation = calculateTrustScore(agent.factorScores, tier);
-            const actualTier = getTrustTierFromScore(evaluation.totalScore);
-            const passed = evaluation.totalScore >= agent.expectedScoreRange.min &&
-                evaluation.totalScore <= agent.expectedScoreRange.max;
-            const result = {
-                agentId,
-                targetTier: `T${tier} ${getTierName(tier)}`,
-                actualTier: `T${actualTier} ${getTierName(actualTier)}`,
-                score: evaluation.totalScore,
-                expectedRange: `${agent.expectedScoreRange.min}-${agent.expectedScoreRange.max}`,
-                passed,
-                compliant: evaluation.compliant,
-                criticalFailures: evaluation.belowThreshold.length,
-            };
-            results.push(result);
-            // Print result
-            const status = passed ? '✓' : '✗';
-            const complianceStatus = evaluation.compliant ? 'COMPLIANT' : `FAILED(${evaluation.belowThreshold.length})`;
-            console.log(`  ${status} ${agentId}: Score=${evaluation.totalScore.toString().padStart(4)} ` +
-                `Target=${result.targetTier.padEnd(15)} Actual=${result.actualTier.padEnd(15)} ` +
-                `[${complianceStatus}]`);
-        }
-    }
-    // Summary
-    console.log('\n' + '='.repeat(80));
-    console.log('TEST SUMMARY');
-    console.log('='.repeat(80));
-    const passed = results.filter(r => r.passed).length;
-    const failed = results.filter(r => !r.passed).length;
-    const compliant = results.filter(r => r.compliant).length;
-    console.log(`\nTotal Agents Tested: ${results.length}`);
-    console.log(`Passed (in expected range): ${passed} (${((passed / results.length) * 100).toFixed(1)}%)`);
-    console.log(`Failed (outside range): ${failed} (${((failed / results.length) * 100).toFixed(1)}%)`);
-    console.log(`Compliant (met all critical factors): ${compliant} (${((compliant / results.length) * 100).toFixed(1)}%)`);
-    // Distribution by tier
-    console.log('\nDISTRIBUTION BY ACTUAL TIER:');
-    console.log('-'.repeat(40));
-    for (let t = 0; t <= 7; t++) {
-        const inTier = results.filter(r => r.actualTier.startsWith(`T${t}`)).length;
-        const bar = '█'.repeat(Math.round(inTier / 2));
-        console.log(`  T${t} ${getTierName(t).padEnd(12)}: ${inTier.toString().padStart(3)} ${bar}`);
-    }
-    // Score distribution
-    console.log('\nSCORE DISTRIBUTION:');
-    console.log('-'.repeat(40));
-    const scoreRanges = [
-        { label: '0-199', min: 0, max: 199 },
-        { label: '200-349', min: 200, max: 349 },
-        { label: '350-499', min: 350, max: 499 },
-        { label: '500-649', min: 500, max: 649 },
-        { label: '650-799', min: 650, max: 799 },
-        { label: '800-875', min: 800, max: 875 },
-        { label: '876-949', min: 876, max: 949 },
-        { label: '950-1000', min: 950, max: 1000 },
-    ];
-    for (const range of scoreRanges) {
-        const count = results.filter(r => r.score >= range.min && r.score <= range.max).length;
-        const bar = '█'.repeat(Math.round(count / 2));
-        console.log(`  ${range.label.padEnd(10)}: ${count.toString().padStart(3)} ${bar}`);
-    }
-    // Failed agents detail
-    if (failed > 0) {
-        console.log('\nFAILED AGENTS:');
-        console.log('-'.repeat(60));
-        results.filter(r => !r.passed).forEach(r => {
-            console.log(`  ${r.agentId}: Score=${r.score} Expected=${r.expectedRange} Got=${r.actualTier}`);
-        });
-    }
-    console.log('\n' + '='.repeat(80));
-    console.log(failed === 0 ? 'ALL TESTS PASSED!' : `${failed} TESTS FAILED`);
-    console.log('='.repeat(80));
-}
-// Run tests
-runTests();
-//# sourceMappingURL=trust-factors.test.js.map

package/dist/validation-gate.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validation-gate.test.d.ts","sourceRoot":"","sources":["../src/validation-gate.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/validation-gate.test.js

@@ -1,419 +0,0 @@
-/**
- * Tests for BASIS Validation Gate
- */
-import { describe, it, expect } from 'vitest';
-import { validateAgent, isValidAgent, createValidationGate, strictValidationGate, productionValidationGate, GateDecision, ValidationSeverity, scoreToTier, } from './validation-gate';
-import { TrustTier } from './trust-factors';
-describe('ValidationGate', () => {
-    // =============================================================================
-    // BASIC VALIDATION TESTS
-    // =============================================================================
-    describe('validateAgent', () => {
-        it('should PASS a valid manifest', () => {
-            const manifest = {
-                agentId: 'a3i.acme-corp.invoice-bot:ABF-L3@1.0.0',
-                organization: 'acme-corp',
-                agentClass: 'invoice-bot',
-                domains: ['A', 'B', 'F'],
-                capabilityLevel: 3,
-                version: '1.0.0',
-                trustScore: 450,
-            };
-            const result = validateAgent(manifest);
-            expect(result.decision).toBe(GateDecision.PASS);
-            expect(result.valid).toBe(true);
-            expect(result.errors).toHaveLength(0);
-        });
-        it('should REJECT manifest missing required agentId', () => {
-            const manifest = {
-                organization: 'acme-corp',
-                trustScore: 450,
-            };
-            const result = validateAgent(manifest);
-            expect(result.decision).toBe(GateDecision.REJECT);
-            expect(result.valid).toBe(false);
-            expect(result.errors.length).toBeGreaterThan(0);
-        });
-        it('should include timing information', () => {
-            const manifest = {
-                agentId: 'test-agent',
-                trustScore: 500,
-            };
-            const result = validateAgent(manifest);
-            expect(result.validatedAt).toBeInstanceOf(Date);
-            expect(result.durationMs).toBeGreaterThanOrEqual(0);
-        });
-        it('should detect invalid CAR format', () => {
-            const manifest = {
-                agentId: 'invalid-format:missing-parts@1.0.0',
-                trustScore: 500,
-            };
-            const result = validateAgent(manifest);
-            const formatIssue = result.issues.find((i) => i.code === 'INVALID_CAR_FORMAT');
-            expect(formatIssue).toBeDefined();
-        });
-        it('should accept simple ID format with info note', () => {
-            const manifest = {
-                agentId: 'simple-agent-id',
-                trustScore: 500,
-            };
-            const result = validateAgent(manifest);
-            expect(result.valid).toBe(true);
-            const infoIssue = result.issues.find((i) => i.code === 'SIMPLE_ID_FORMAT');
-            expect(infoIssue).toBeDefined();
-            expect(infoIssue?.severity).toBe(ValidationSeverity.INFO);
-        });
-    });
-    // =============================================================================
-    // TRUST TIER VALIDATION
-    // =============================================================================
-    describe('trust tier validation', () => {
-        it('should calculate trust tier from score', () => {
-            // T0: 0-199
-            expect(scoreToTier(0)).toBe(TrustTier.T0_SANDBOX);
-            expect(scoreToTier(199)).toBe(TrustTier.T0_SANDBOX);
-            // T1: 200-349
-            expect(scoreToTier(200)).toBe(TrustTier.T1_OBSERVED);
-            expect(scoreToTier(349)).toBe(TrustTier.T1_OBSERVED);
-            // T2: 350-500
-            expect(scoreToTier(350)).toBe(TrustTier.T2_PROVISIONAL);
-            expect(scoreToTier(500)).toBe(TrustTier.T2_PROVISIONAL);
-            // T3: 501-649
-            expect(scoreToTier(501)).toBe(TrustTier.T3_MONITORED);
-            expect(scoreToTier(649)).toBe(TrustTier.T3_MONITORED);
-            // T4: 650-799
-            expect(scoreToTier(650)).toBe(TrustTier.T4_STANDARD);
-            expect(scoreToTier(799)).toBe(TrustTier.T4_STANDARD);
-            // T5: 800-875
-            expect(scoreToTier(800)).toBe(TrustTier.T5_TRUSTED);
-            expect(scoreToTier(875)).toBe(TrustTier.T5_TRUSTED);
-            // T6: 876-950
-            expect(scoreToTier(876)).toBe(TrustTier.T6_CERTIFIED);
-            expect(scoreToTier(950)).toBe(TrustTier.T6_CERTIFIED);
-            // T7: 951-1000
-            expect(scoreToTier(951)).toBe(TrustTier.T7_AUTONOMOUS);
-            expect(scoreToTier(1000)).toBe(TrustTier.T7_AUTONOMOUS);
-        });
-        it('should REJECT when trust tier is below minimum', () => {
-            const manifest = {
-                agentId: 'test-agent',
-                trustScore: 100, // T0
-            };
-            const result = validateAgent(manifest, undefined, {
-                minimumTrustTier: TrustTier.T3_MONITORED,
-            });
-            expect(result.decision).toBe(GateDecision.REJECT);
-            expect(result.errors.some((e) => e.code === 'INSUFFICIENT_TRUST_TIER')).toBe(true);
-        });
-        it('should PASS when trust tier meets minimum', () => {
-            const manifest = {
-                agentId: 'test-agent',
-                trustScore: 700, // T4 (650-799)
-            };
-            const result = validateAgent(manifest, undefined, {
-                minimumTrustTier: TrustTier.T3_MONITORED,
-            });
-            expect(result.decision).toBe(GateDecision.PASS);
-            expect(result.trustTier).toBe(TrustTier.T4_STANDARD);
-        });
-        it('should warn when trust score is missing', () => {
-            const manifest = {
-                agentId: 'test-agent',
-            };
-            const result = validateAgent(manifest);
-            expect(result.warnings.some((w) => w.code === 'MISSING_TRUST_SCORE')).toBe(true);
-        });
-    });
-    // =============================================================================
-    // PROFILE VALIDATION
-    // =============================================================================
-    describe('profile validation', () => {
-        const validProfile = {
-            agentId: 'a3i.acme-corp.invoice-bot:ABF-L3@1.0.0',
-            organization: 'acme-corp',
-            agentClass: 'invoice-bot',
-            approvedDomains: ['A', 'B', 'F'],
-            maxCapabilityLevel: 4,
-            approvedCapabilities: ['CAP-READ-PUBLIC', 'CAP-DB-READ', 'CAP-WRITE-APPROVED'],
-            trustScore: 500,
-            registeredAt: new Date('2024-01-01'),
-        };
-        it('should PASS when manifest matches profile', () => {
-            const manifest = {
-                agentId: 'a3i.acme-corp.invoice-bot:ABF-L3@1.0.0',
-                organization: 'acme-corp',
-                agentClass: 'invoice-bot',
-                domains: ['A', 'B'],
-                capabilityLevel: 3,
-                trustScore: 500,
-            };
-            const result = validateAgent(manifest, validProfile);
-            expect(result.decision).toBe(GateDecision.PASS);
-            expect(result.valid).toBe(true);
-        });
-        it('should REJECT when organization mismatches', () => {
-            const manifest = {
-                agentId: 'test-agent',
-                organization: 'evil-corp',
-                trustScore: 500,
-            };
-            const result = validateAgent(manifest, validProfile);
-            expect(result.decision).toBe(GateDecision.REJECT);
-            expect(result.errors.some((e) => e.code === 'ORG_MISMATCH')).toBe(true);
-        });
-        it('should REJECT when capability level exceeds maximum', () => {
-            const manifest = {
-                agentId: 'test-agent',
-                organization: 'acme-corp',
-                capabilityLevel: 7, // exceeds profile max of 4
-                trustScore: 500,
-            };
-            const result = validateAgent(manifest, validProfile);
-            expect(result.decision).toBe(GateDecision.REJECT);
-            expect(result.errors.some((e) => e.code === 'CAPABILITY_LEVEL_EXCEEDED')).toBe(true);
-        });
-        it('should REJECT unauthorized domains', () => {
-            const manifest = {
-                agentId: 'test-agent',
-                organization: 'acme-corp',
-                domains: ['A', 'B', 'S'], // S not approved
-                trustScore: 500,
-            };
-            const result = validateAgent(manifest, validProfile);
-            expect(result.decision).toBe(GateDecision.REJECT);
-            expect(result.errors.some((e) => e.code === 'UNAUTHORIZED_DOMAINS')).toBe(true);
-        });
-        it('should warn on unauthorized capabilities', () => {
-            const manifest = {
-                agentId: 'test-agent',
-                organization: 'acme-corp',
-                requestedCapabilities: ['CAP-READ-PUBLIC', 'CAP-SYSTEM-ADMIN-FULL'], // admin not approved
-                trustScore: 500,
-            };
-            const result = validateAgent(manifest, validProfile);
-            expect(result.warnings.some((w) => w.code === 'UNAUTHORIZED_CAPABILITIES')).toBe(true);
-        });
-        it('should REJECT when profile required but missing', () => {
-            const manifest = {
-                agentId: 'test-agent',
-                trustScore: 500,
-            };
-            const result = validateAgent(manifest, undefined, {
-                requireRegisteredProfile: true,
-            });
-            expect(result.decision).toBe(GateDecision.REJECT);
-            expect(result.errors.some((e) => e.code === 'PROFILE_NOT_FOUND')).toBe(true);
-        });
-    });
-    // =============================================================================
-    // CAPABILITY VALIDATION
-    // =============================================================================
-    describe('capability validation', () => {
-        it('should allow capabilities matching trust tier', () => {
-            const manifest = {
-                agentId: 'test-agent',
-                trustScore: 700, // T4_STANDARD (650-799)
-                requestedCapabilities: ['CAP-READ-PUBLIC', 'CAP-AGENT-COMMUNICATE'],
-            };
-            const result = validateAgent(manifest);
-            expect(result.allowedCapabilities).toContain('CAP-READ-PUBLIC');
-            expect(result.allowedCapabilities).toContain('CAP-AGENT-COMMUNICATE');
-            expect(result.deniedCapabilities).toBeUndefined();
-        });
-        it('should deny capabilities above trust tier', () => {
-            const manifest = {
-                agentId: 'test-agent',
-                trustScore: 100, // T0_SANDBOX
-                requestedCapabilities: ['CAP-READ-PUBLIC', 'CAP-AGENT-SPAWN'], // spawn requires T6
-            };
-            const result = validateAgent(manifest);
-            expect(result.allowedCapabilities).toContain('CAP-READ-PUBLIC');
-            expect(result.deniedCapabilities).toContain('CAP-AGENT-SPAWN');
-        });
-        it('should provide recommendations for denied capabilities', () => {
-            const manifest = {
-                agentId: 'test-agent',
-                trustScore: 100,
-                requestedCapabilities: ['CAP-AGENT-SPAWN'],
-            };
-            const result = validateAgent(manifest);
-            expect(result.recommendations).toBeDefined();
-            expect(result.recommendations?.some((r) => r.includes('trust score'))).toBe(true);
-        });
-    });
-    // =============================================================================
-    // REQUIRED DOMAINS
-    // =============================================================================
-    describe('required domains', () => {
-        it('should REJECT when required domains are missing', () => {
-            const manifest = {
-                agentId: 'test-agent',
-                domains: ['A', 'B'],
-                trustScore: 500,
-            };
-            const result = validateAgent(manifest, undefined, {
-                requiredDomains: ['A', 'F'], // F is missing
-            });
-            expect(result.decision).toBe(GateDecision.REJECT);
-            expect(result.errors.some((e) => e.code === 'MISSING_REQUIRED_DOMAINS')).toBe(true);
-        });
-        it('should PASS when all required domains present', () => {
-            const manifest = {
-                agentId: 'test-agent',
-                domains: ['A', 'B', 'F'],
-                trustScore: 500,
-            };
-            const result = validateAgent(manifest, undefined, {
-                requiredDomains: ['A', 'F'],
-            });
-            expect(result.decision).toBe(GateDecision.PASS);
-        });
-    });
-    // =============================================================================
-    // STRICT MODE
-    // =============================================================================
-    describe('strict mode', () => {
-        it('should REJECT on warnings in strict mode', () => {
-            const manifest = {
-                agentId: 'test-agent',
-                // No trust score - generates warning
-            };
-            const normalResult = validateAgent(manifest, undefined, { strict: false });
-            const strictResult = validateAgent(manifest, undefined, { strict: true });
-            expect(normalResult.decision).toBe(GateDecision.PASS);
-            expect(strictResult.decision).toBe(GateDecision.REJECT);
-        });
-    });
-    // =============================================================================
-    // CUSTOM VALIDATORS
-    // =============================================================================
-    describe('custom validators', () => {
-        it('should run custom validators', () => {
-            const manifest = {
-                agentId: 'test-agent',
-                trustScore: 500,
-                metadata: { version: '0.0.1' },
-            };
-            const customValidator = (m) => {
-                const issues = [];
-                if (m.metadata?.version === '0.0.1') {
-                    issues.push({
-                        code: 'UNSTABLE_VERSION',
-                        message: 'Agent is using unstable version',
-                        severity: ValidationSeverity.WARNING,
-                    });
-                }
-                return issues;
-            };
-            const result = validateAgent(manifest, undefined, {
-                customValidators: [customValidator],
-            });
-            expect(result.warnings.some((w) => w.code === 'UNSTABLE_VERSION')).toBe(true);
-        });
-        it('should handle custom validator errors gracefully', () => {
-            const manifest = {
-                agentId: 'test-agent',
-                trustScore: 500,
-            };
-            const failingValidator = () => {
-                throw new Error('Validator crashed');
-            };
-            const result = validateAgent(manifest, undefined, {
-                customValidators: [failingValidator],
-            });
-            // Should not crash, just add a warning
-            expect(result.warnings.some((w) => w.code === 'CUSTOM_VALIDATOR_ERROR')).toBe(true);
-        });
-    });
-    // =============================================================================
-    // HELPER FUNCTIONS
-    // =============================================================================
-    describe('isValidAgent', () => {
-        it('should return true for valid agent', () => {
-            const manifest = {
-                agentId: 'test-agent',
-                trustScore: 500,
-            };
-            expect(isValidAgent(manifest)).toBe(true);
-        });
-        it('should return false for invalid agent', () => {
-            const manifest = {};
-            expect(isValidAgent(manifest)).toBe(false);
-        });
-    });
-    describe('createValidationGate', () => {
-        it('should create gate with preset options', () => {
-            const gate = createValidationGate({
-                minimumTrustTier: TrustTier.T3_MONITORED,
-            });
-            const lowTrustManifest = {
-                agentId: 'test-agent',
-                trustScore: 100,
-            };
-            const result = gate.validate(lowTrustManifest);
-            expect(result.decision).toBe(GateDecision.REJECT);
-        });
-        it('should allow option overrides', () => {
-            const gate = createValidationGate({
-                minimumTrustTier: TrustTier.T5_TRUSTED,
-            });
-            const manifest = {
-                agentId: 'test-agent',
-                trustScore: 700, // T4 (650-799)
-            };
-            // With default options, should fail (T4 < T5)
-            const result1 = gate.validate(manifest);
-            expect(result1.decision).toBe(GateDecision.REJECT);
-            // With override, should pass (T4 >= T3)
-            const result2 = gate.validate(manifest, undefined, {
-                minimumTrustTier: TrustTier.T3_MONITORED,
-            });
-            expect(result2.decision).toBe(GateDecision.PASS);
-        });
-    });
-    describe('preset gates', () => {
-        it('strictValidationGate should reject on warnings', () => {
-            const manifest = {
-                agentId: 'test-agent',
-                // Missing trustScore generates warning
-            };
-            expect(strictValidationGate.isValid(manifest)).toBe(false);
-        });
-        it('productionValidationGate should require profile', () => {
-            const manifest = {
-                agentId: 'test-agent',
-                trustScore: 500,
-            };
-            const result = productionValidationGate.validate(manifest);
-            expect(result.errors.some((e) => e.code === 'PROFILE_NOT_FOUND')).toBe(true);
-        });
-    });
-    // =============================================================================
-    // ESCALATION
-    // =============================================================================
-    describe('escalation', () => {
-        it('should ESCALATE when capability escalation allowed and denied caps exist', () => {
-            const manifest = {
-                agentId: 'test-agent',
-                trustScore: 100, // T0
-                requestedCapabilities: ['CAP-AGENT-SPAWN'], // Requires T6
-            };
-            const result = validateAgent(manifest, undefined, {
-                allowCapabilityEscalation: true,
-            });
-            expect(result.decision).toBe(GateDecision.ESCALATE);
-        });
-        it('should REJECT when capability escalation not allowed', () => {
-            const manifest = {
-                agentId: 'test-agent',
-                trustScore: 100,
-                requestedCapabilities: ['CAP-AGENT-SPAWN'],
-            };
-            const result = validateAgent(manifest, undefined, {
-                allowCapabilityEscalation: false,
-            });
-            expect(result.decision).toBe(GateDecision.REJECT);
-        });
-    });
-});
-//# sourceMappingURL=validation-gate.test.js.map

package/hardhat.config.ts

@@ -1,55 +0,0 @@
-import { HardhatUserConfig } from 'hardhat/config';
-import '@nomicfoundation/hardhat-ethers';
-import * as dotenv from 'dotenv';
-
-dotenv.config();
-
-const config: HardhatUserConfig = {
-  solidity: {
-    version: '0.8.20',
-    settings: {
-      optimizer: {
-        enabled: true,
-        runs: 200,
-      },
-    },
-  },
-
-  networks: {
-    hardhat: {
-      chainId: 31337,
-    },
-
-    // Ethereum Sepolia Testnet (uses ETH)
-    sepolia: {
-      url: process.env.SEPOLIA_RPC_URL || 'https://ethereum-sepolia-rpc.publicnode.com',
-      accounts: process.env.PRIVATE_KEY && process.env.PRIVATE_KEY.startsWith('0x') && process.env.PRIVATE_KEY.length === 66 ? [process.env.PRIVATE_KEY] : [],
-      chainId: 11155111,
-    },
-
-    // Polygon Amoy Testnet
-    amoy: {
-      url: process.env.AMOY_RPC_URL || 'https://rpc-amoy.polygon.technology',
-      accounts: process.env.PRIVATE_KEY && process.env.PRIVATE_KEY.startsWith('0x') && process.env.PRIVATE_KEY.length === 66 ? [process.env.PRIVATE_KEY] : [],
-      chainId: 80002,
-      gasPrice: 30000000000, // 30 gwei
-    },
-
-    // Polygon Mainnet (uses POL token)
-    polygon: {
-      url: process.env.POLYGON_RPC_URL || 'https://polygon-rpc.com',
-      accounts: process.env.PRIVATE_KEY && process.env.PRIVATE_KEY.startsWith('0x') && process.env.PRIVATE_KEY.length === 66 ? [process.env.PRIVATE_KEY] : [],
-      chainId: 137,
-      gasPrice: 50000000000, // 50 gwei
-    },
-  },
-
-  paths: {
-    sources: './contracts',
-    tests: './test',
-    cache: './cache',
-    artifacts: './artifacts',
-  },
-};
-
-export default config;