@atlasnomos/atlas 1.1.15 → 10.0.1

package/src/kernel/automation/AutomationSchema.js

@@ -0,0 +1,109 @@
+/**
+ * ATLAS v10 — Automation Schema (AURORA)
+ * 
+ * PURPOSE: Define the immutable schema for Standing Automation Grants.
+ * 
+ * SECURITY INVARIANTS:
+ * - Grants are strictly typed and Sentinel-signed.
+ * - Time-bounded (issued_at, expires_at).
+ * - Scope-limited (frequency, cost, runtime).
+ * - PROD-ONLY: Validating this schema in DEV is prohibited.
+ * 
+ * @module kernel/automation/AutomationSchema
+ */
+
+const { getActiveMode, isProdOrHigher } = require('../modes/ActiveMode');
+const { panic } = require('../boot/HardKill');
+
+// ═══════════════════════════════════════════════════════════════
+// EVENTS
+// ═══════════════════════════════════════════════════════════════
+
+const AUTOMATION_EVENTS = Object.freeze({
+    REGISTERED: 'AUTOMATION_REGISTERED',
+    TRIGGERED: 'AUTOMATION_TRIGGERED',
+    COMPLETE: 'AUTOMATION_EXECUTION_COMPLETE',
+    REVOKED: 'AUTOMATION_REVOKED',
+    EXPIRED: 'AUTOMATION_EXPIRED'
+});
+
+// ═══════════════════════════════════════════════════════════════
+// SCHEMA VALIDATION
+// ═══════════════════════════════════════════════════════════════
+
+class AutomationSchema {
+
+    /**
+     * Validate that a plain object matches the AutomationGrant schema.
+     * 
+     * @param {Object} grant - The grant object to validate
+     * @throws {Error} If validation fails or called in DEV
+     */
+    static validateGrant(grant) {
+        // INVARIANT: Automation logic is PROD-only via Schema
+        if (!isProdOrHigher()) {
+            // In DEV, this class functions exist but usage logic usually blocks higher up.
+            // However, if we reach here in DEV, we must reject strict validation
+            // or simple return false/throw to prevent "accidental" usage.
+            // Per prompt: "DEV MODE MUST NOT ... VERIFY ... AUTOMATIONS"
+            // So we throw.
+            throw new Error('DEV_MODE_VIOLATION: Automation Schema validation is prohibited in DEV.');
+        }
+
+        if (!grant || typeof grant !== 'object') {
+            throw new Error('Invalid Grant: Must be an object');
+        }
+
+        const requiredFields = [
+            'grant_id',
+            'scope',
+            'trigger',
+            'policy_hash',
+            'issued_at',
+            'expires_at',
+            'sentinel_key_id',
+            'sentinel_signature'
+        ];
+
+        for (const field of requiredFields) {
+            if (!grant[field]) {
+                throw new Error(`Invalid Grant: Missing field '${field}'`);
+            }
+        }
+
+        // Validate Scope
+        this._validateScope(grant.scope);
+
+        // Validate Trigger
+        this._validateTrigger(grant.trigger);
+
+        return true;
+    }
+
+    static _validateScope(scope) {
+        if (!scope || typeof scope !== 'object') throw new Error('Invalid Scope');
+
+        if (!Array.isArray(scope.allowed_actions)) throw new Error('Invalid Scope: allowed_actions must be array');
+        if (typeof scope.max_cost !== 'number') throw new Error('Invalid Scope: max_cost must be number');
+        if (typeof scope.max_runtime_ms !== 'number') throw new Error('Invalid Scope: max_runtime_ms must be number');
+
+        // Frequency is ISO duration string, e.g. "PT1H"
+        if (typeof scope.max_frequency !== 'string') throw new Error('Invalid Scope: max_frequency must be ISO string');
+    }
+
+    static _validateTrigger(trigger) {
+        if (!trigger || typeof trigger !== 'object') throw new Error('Invalid Trigger');
+
+        const validTypes = ['TIME', 'EVENT', 'STATE', 'SENTINEL'];
+        if (!validTypes.includes(trigger.type)) {
+            throw new Error(`Invalid Trigger: type must be one of ${validTypes.join(', ')}`);
+        }
+
+        if (typeof trigger.condition !== 'string') throw new Error('Invalid Trigger: condition must be string');
+    }
+}
+
+module.exports = {
+    AutomationSchema,
+    AUTOMATION_EVENTS
+};

package/src/kernel/automation/AutomationVerifier.js

@@ -0,0 +1,135 @@
+/**
+ * ATLAS v10.2 — Automation Verifier (AURORA+)
+ * 
+ * PURPOSE: Enforce scope and invariants for Automation Execution.
+ * 
+ * SECURITY INVARIANTS:
+ * - Policy Hash Match: Grant must match current active policy.
+ * - Frequency Limit: Kernel-enforced via LastRunLedger (v10.2).
+ * - Cost Limit: Check predicted cost usage.
+ * 
+ * @module kernel/automation/AutomationVerifier
+ */
+
+const { isProdOrHigher } = require('../modes/ActiveMode');
+const { panic } = require('../boot/HardKill');
+const SentinelInterface = require('../constitution/SentinelInterface');
+const { AUTOMATION_EVENTS } = require('./AutomationSchema');
+const { checkFrequencyLimit } = require('../constitution/invariants/frequency.invariants');
+const { getInstance: getLedger } = require('./LastRunLedger');
+const crypto = require('crypto');
+
+class AutomationVerifier {
+
+    /**
+     * Verify if a specific grant can execute NOW.
+     * 
+     * @param {Object} grant - The grant object
+     * @param {Object} context - Execution context (current policy hash, etc)
+     * @returns {Object} { allowed: boolean, reason: string }
+     */
+    static checkExecutionEligibility(grant, context = {}) {
+        if (!isProdOrHigher()) {
+            throw new Error('DEV_MODE_VIOLATION: AutomationVerifier running in DEV');
+        }
+
+        const sentinel = SentinelInterface.getInstance();
+        const grantId = grant.grant_id;
+
+        // Emit Execution Attempt
+        sentinel.logAudit({
+            event: 'AUTOMATION_EXECUTION_ATTEMPT',
+            grant_id: grantId,
+            timestamp: new Date().toISOString()
+        });
+
+        // 1. Policy Integrity
+        if (context.currentPolicyHash && grant.policy_hash !== context.currentPolicyHash) {
+            return { allowed: false, reason: 'POLICY_HASH_MISMATCH' };
+        }
+
+        // 2. Expiry Check
+        if (new Date() > new Date(grant.expires_at)) {
+            return { allowed: false, reason: 'GRANT_EXPIRED' };
+        }
+
+        // 3. Frequency Check (v10.2: Kernel-Enforced)
+        const frequencyCheck = checkFrequencyLimit(grant);
+        if (!frequencyCheck.allowed) {
+            return {
+                allowed: false,
+                reason: frequencyCheck.reason,
+                violation: frequencyCheck.violation
+            };
+        }
+
+        // 4. Cost Check
+        if (context.estimatedCost && context.estimatedCost > grant.scope.max_cost) {
+            return { allowed: false, reason: 'COST_LIMIT_EXCEEDED' };
+        }
+
+        // All checks passed
+        sentinel.logAudit({
+            event: 'AUTOMATION_EXECUTION_ACCEPTED',
+            grant_id: grantId,
+            timestamp: new Date().toISOString()
+        });
+
+        return { allowed: true };
+    }
+
+    /**
+     * Execute automation with full lifecycle tracking.
+     * 
+     * @param {Object} grant - The grant object
+     * @param {Function} executeFn - The execution function
+     * @param {Object} context - Execution context
+     * @returns {Promise<Object>} Execution result
+     */
+    static async executeWithTracking(grant, executeFn, context = {}) {
+        if (!isProdOrHigher()) {
+            throw new Error('DEV_MODE_VIOLATION: executeWithTracking running in DEV');
+        }
+
+        const grantId = grant.grant_id;
+        const ledger = getLedger();
+
+        // Generate approval hash for this execution
+        const approvalHash = crypto.createHash('sha256')
+            .update(`${grantId}:${Date.now()}:${JSON.stringify(context)}`)
+            .digest('hex');
+
+        // Write-Ahead: Record start BEFORE execution
+        ledger.recordExecutionStart(grantId, approvalHash);
+
+        let result;
+        let eventHash;
+
+        try {
+            // Execute the automation
+            result = await executeFn();
+
+            // Hash the result for audit binding
+            eventHash = crypto.createHash('sha256')
+                .update(JSON.stringify(result || {}))
+                .digest('hex');
+
+            // Mark completion
+            ledger.recordExecutionComplete(grantId, eventHash);
+
+        } catch (error) {
+            // Execution failed - still record completion to unblock future runs
+            eventHash = crypto.createHash('sha256')
+                .update(`ERROR:${error.message}`)
+                .digest('hex');
+
+            ledger.recordExecutionComplete(grantId, eventHash);
+
+            throw error;
+        }
+
+        return { result, eventHash, approvalHash };
+    }
+}
+
+module.exports = { AutomationVerifier };

package/src/kernel/automation/LastRunLedger.js

@@ -0,0 +1,220 @@
+/**
+ * ATLAS v10.2 — Last-Run State Ledger (AURORA+)
+ * 
+ * PURPOSE: Persistent frequency state tracking for Automation Grants.
+ * 
+ * SECURITY INVARIANTS:
+ * - PROD-ONLY: Like all automation, this is blocked in DEV.
+ * - Write-Ahead: State is written BEFORE execution begins.
+ * - Atomic: Files are written via temp+rename for crash safety.
+ * - Hash-Chained: Events are logged to Sentinel audit spine.
+ * 
+ * @module kernel/automation/LastRunLedger
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { isProdOrHigher } = require('../modes/ActiveMode');
+const { panic } = require('../boot/HardKill');
+const SentinelInterface = require('../constitution/SentinelInterface');
+
+const STATE_DIR = path.join(process.cwd(), '.atlas', 'automation', 'state');
+
+class LastRunLedger {
+    constructor() {
+        if (!isProdOrHigher()) {
+            throw new Error('DEV_MODE_VIOLATION: LastRunLedger cannot be instantiated in DEV.');
+        }
+        this._ensureStateDir();
+        this._sessionId = `BOOT_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
+    }
+
+    _ensureStateDir() {
+        if (!fs.existsSync(STATE_DIR)) {
+            fs.mkdirSync(STATE_DIR, { recursive: true });
+        }
+    }
+
+    _getStatePath(grantId) {
+        // Sanitize grantId to prevent path traversal
+        const safeId = grantId.replace(/[^a-zA-Z0-9_-]/g, '_');
+        return path.join(STATE_DIR, `${safeId}.state.json`);
+    }
+
+    /**
+     * Parse ISO-8601 Duration to milliseconds.
+     * Supports: PT1H, PT30M, PT60S, P1D
+     * 
+     * @param {string} duration - ISO-8601 duration string
+     * @returns {number} milliseconds
+     */
+    _parseDuration(duration) {
+        if (!duration || typeof duration !== 'string') return 0;
+
+        const match = duration.match(/^P(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/);
+        if (!match) return 0;
+
+        const days = parseInt(match[1] || '0', 10);
+        const hours = parseInt(match[2] || '0', 10);
+        const mins = parseInt(match[3] || '0', 10);
+        const secs = parseInt(match[4] || '0', 10);
+
+        return ((days * 24 * 60 * 60) + (hours * 60 * 60) + (mins * 60) + secs) * 1000;
+    }
+
+    /**
+     * Load state for a grant.
+     * 
+     * @param {string} grantId 
+     * @returns {Object|null}
+     */
+    getState(grantId) {
+        const statePath = this._getStatePath(grantId);
+        if (!fs.existsSync(statePath)) return null;
+
+        try {
+            return JSON.parse(fs.readFileSync(statePath, 'utf8'));
+        } catch (e) {
+            // Corrupt state file = fail-close
+            panic('AUTOMATION_STATE_CORRUPT', { grantId, error: e.message });
+        }
+    }
+
+    /**
+     * Check if execution is allowed based on frequency.
+     * 
+     * @param {string} grantId 
+     * @param {string} maxFrequency - ISO-8601 duration (e.g., "PT1H")
+     * @returns {{ allowed: boolean, reason?: string, lastExecutionAt?: string }}
+     */
+    canExecute(grantId, maxFrequency) {
+        const state = this.getState(grantId);
+        const frequencyMs = this._parseDuration(maxFrequency);
+
+        if (!state) {
+            // Never executed before, allowed
+            return { allowed: true };
+        }
+
+        // Check for incomplete execution (crash recovery)
+        if (state.status === 'PENDING') {
+            // Previous execution did not complete. Fail-close.
+            return {
+                allowed: false,
+                reason: 'INCOMPLETE_EXECUTION_DETECTED',
+                lastExecutionAt: state.last_execution_at
+            };
+        }
+
+        const lastRun = new Date(state.last_execution_at).getTime();
+        const now = Date.now();
+        const elapsed = now - lastRun;
+
+        // Clock rollback detection
+        if (elapsed < 0) {
+            return {
+                allowed: false,
+                reason: 'CLOCK_ROLLBACK_DETECTED',
+                lastExecutionAt: state.last_execution_at
+            };
+        }
+
+        if (elapsed < frequencyMs) {
+            const nextAllowedAt = new Date(lastRun + frequencyMs).toISOString();
+            return {
+                allowed: false,
+                reason: 'FREQUENCY_LIMIT',
+                lastExecutionAt: state.last_execution_at,
+                nextAllowedAt
+            };
+        }
+
+        return { allowed: true, lastExecutionAt: state.last_execution_at };
+    }
+
+    /**
+     * Record execution start (Write-Ahead).
+     * 
+     * @param {string} grantId 
+     * @param {string} approvalHash - Hash of the approval context
+     */
+    recordExecutionStart(grantId, approvalHash) {
+        const statePath = this._getStatePath(grantId);
+        const existingState = this.getState(grantId) || { execution_count: 0 };
+
+        const newState = {
+            grant_id: grantId,
+            last_execution_at: new Date().toISOString(),
+            execution_count: existingState.execution_count + 1,
+            session_id: this._sessionId,
+            approval_hash: approvalHash,
+            status: 'PENDING', // Mark as pending until complete
+            event_hash: null   // Will be filled on completion
+        };
+
+        // Atomic write via temp file
+        const tempPath = `${statePath}.tmp`;
+        fs.writeFileSync(tempPath, JSON.stringify(newState, null, 2), 'utf8');
+        fs.renameSync(tempPath, statePath);
+
+        // Emit to audit chain
+        SentinelInterface.getInstance().logAudit({
+            event: 'AUTOMATION_EXECUTION_START',
+            grant_id: grantId,
+            execution_count: newState.execution_count,
+            session_id: this._sessionId,
+            approval_hash: approvalHash,
+            timestamp: newState.last_execution_at
+        });
+    }
+
+    /**
+     * Record execution completion.
+     * 
+     * @param {string} grantId 
+     * @param {string} eventHash - Hash of the execution result
+     */
+    recordExecutionComplete(grantId, eventHash) {
+        const statePath = this._getStatePath(grantId);
+        const state = this.getState(grantId);
+
+        if (!state) {
+            panic('AUTOMATION_STATE_MISSING', { grantId, context: 'recordExecutionComplete' });
+        }
+
+        state.status = 'COMPLETE';
+        state.event_hash = eventHash;
+
+        // Atomic write
+        const tempPath = `${statePath}.tmp`;
+        fs.writeFileSync(tempPath, JSON.stringify(state, null, 2), 'utf8');
+        fs.renameSync(tempPath, statePath);
+
+        // Emit to audit chain
+        SentinelInterface.getInstance().logAudit({
+            event: 'AUTOMATION_EXECUTION_COMPLETE',
+            grant_id: grantId,
+            execution_count: state.execution_count,
+            session_id: state.session_id,
+            event_hash: eventHash,
+            timestamp: new Date().toISOString()
+        });
+    }
+}
+
+// Singleton
+let _instance = null;
+
+function getInstance() {
+    if (!_instance) {
+        if (isProdOrHigher()) {
+            _instance = new LastRunLedger();
+        } else {
+            throw new Error('DEV_MODE_VIOLATION: Accessing LastRunLedger in DEV');
+        }
+    }
+    return _instance;
+}
+
+module.exports = { LastRunLedger, getInstance };

package/src/kernel/boot/Bootstrap.js

@@ -102,7 +102,14 @@ const InvariantRegistry = require('../constitution/InvariantRegistry');
 const InvariantChecker = require('../constitution/InvariantChecker');
 const { verifyAtBoot: verifyInvariantHash } = require('../constitution/InvariantHashLock');
 const { verifyDormancy } = require('../constitution/RingDormancyGate');
+
+// Ring-0 Mode System (PROD enforcement)
+const { lockMode, getActiveMode, isProdOrHigher, getLockMetadata } = require('../modes/ActiveMode');
 const { getInstance: getTierManager } = require('../constitution/TierManager');
+const SentinelInterface = require('../constitution/SentinelInterface');
+const { DirectoryHasher } = require('../crypto/DirectoryHasher'); // R-03 Hardening
+const { getInstance: getAutomationRegistry } = require('../automation/AutomationRegistry'); // AURORA
+
 
 // Ring-0 Operator
 const { getInstance: getIdentityContext } = require('../operator/IdentityContext');
@@ -156,6 +163,63 @@ class KernelBootstrap {
         const tier = this.tierManager.getTier();
         this.tierManager.displayBanner();
 
+        // V3: Lock mode at boot (IMMUTABLE after this point)
+        const activeMode = lockMode(tier);
+        console.log(`  ✓ Mode Locked: ${tier} (immutable)`);
+        if (isProdOrHigher()) {
+            console.log('  ✓ PROD Enforcement: ACTIVE (fail-close)');
+        }
+
+        // R-03 FIX: Boot Sequence Trust Sealing
+        // Emit BOOT_TRUST_SEALED (Genesis Context for Replay)
+        try {
+            const Sentinel = SentinelInterface.SentinelInterface || SentinelInterface;
+            if (Sentinel.getInstance) {
+                const pkg = require('../../../package.json');
+                const lockMeta = getLockMetadata();
+
+                // Collect Trust Seal Input
+                const sealMetrics = {
+                    kernel_version: pkg.version,
+                    tier,
+                    mode: activeMode,
+                    build_hash: configHash || 'unknown',
+                    lock_metadata: lockMeta,
+                    // R-03B FIX: Real Deterministic Config Hashing
+                    config_hash: (function () {
+                        try {
+                            // Hash <root>/config recursively
+                            const configDir = path.resolve(process.cwd(), 'config');
+                            return DirectoryHasher.hashDir(configDir);
+                        } catch (hashErr) {
+                            // PROD FAIL-CLOSE: If we cannot seal the config, we cannot boot.
+                            // This catches symlinks (SECURITY VIOLATION) or FS errors.
+                            if (tier === 'PROD' || tier === 'FORTRESS') {
+                                panic('CONFIG_SEAL_FAILURE', {
+                                    reason: 'Failed to compute deterministic config hash',
+                                    error: hashErr.message
+                                });
+                            }
+                            // DEV: Warn but proceed (with tainted seal)
+                            console.warn(`  ! Config Hash Failed: ${hashErr.message}`);
+                            return `HASH_FAILED:${hashErr.message}`;
+                        }
+                    })(),
+                    registry_status: this.tierManager.requiresSentinel() ? 'REQUIRED' : 'OPTIONAL'
+                };
+
+                Sentinel.getInstance().logAudit({
+                    event: 'BOOT_TRUST_SEALED',
+                    timestamp: new Date().toISOString(),
+                    seal_metrics: sealMetrics
+                });
+                console.log('  ✓ Boot Trust Seal: EMITTED');
+            }
+        } catch (e) {
+            console.warn('  ! Failed to emit BOOT_TRUST_SEALED:', e.message);
+            // In PROD this technically should be fatal, but usually covered by specific invariants
+        }
+
         // TASK 4: Enforce Tier Restriction in LGM
         if (IS_LGM && (tier === 'PROD' || tier === 'FORTRESS')) {
             panic('LGM_TIER_VIOLATION', {
@@ -188,6 +252,24 @@ class KernelBootstrap {
         this.identityContext = getIdentityContext();
         this.identityContext.establish({ traceId, source: 'kernel_boot' });
 
+        // V2 SECURITY: Initialize Sentinel Key Registry (MUST be before any verification)
+        const { getInstance: getKeyRegistry } = require('../sentinel/KeyRegistry');
+        const keyRegistry = getKeyRegistry();
+        const keyRegStatus = keyRegistry.initialize();
+        if (keyRegStatus.success) {
+            console.log(`  ✓ Sentinel Key Registry: Initialized (${keyRegStatus.keyCount || 0} keys)`);
+        }
+
+        // AURORA: Initialize Automation Registry (PROD Only)
+        const currentMode = getActiveMode();
+        if (currentMode.id === 'PROD' || currentMode.id === 'FORTRESS') {
+            console.log('  ► Initializing Automation Registry (PROD Enforced)...');
+            const registry = getAutomationRegistry();
+            await registry.initialize();
+        } else {
+            console.log(`  ► Automation Registry SKIPPED (Mode: ${currentMode.id})`);
+        }
+
         // ═══════════════════════════════════════════════════════════════
         // 3.5 Initialize Governance Trackers (ALL TIERS)
         // DEV Mode Honesty: Trackers must be wired regardless of tier
@@ -299,6 +381,29 @@ class KernelBootstrap {
             });
         }
 
+        // PROD HARDENING: Emit MODE_LOCKED event (Root of Trust)
+        // Must happen after successful invariant checks
+        try {
+            const pkg = require('../../../package.json');
+            const lockMeta = getLockMetadata(); // Capture locking timestamp/stack
+
+            const Sentinel = SentinelInterface.SentinelInterface || SentinelInterface;
+            if (Sentinel.getInstance) {
+                Sentinel.getInstance().logAudit({
+                    event: 'MODE_LOCKED',
+                    tier,
+                    mode: activeMode,
+                    kernel_version: pkg.version,
+                    build_hash: configHash || 'unknown',
+                    lock_metadata: lockMeta,
+                    timestamp: new Date().toISOString()
+                });
+            }
+        } catch (e) {
+            console.warn('  ! Failed to emit MODE_LOCKED event:', e.message);
+            // Non-fatal, but noisy
+        }
+
         // V2: tier now comes from TierManager
 
         // Hardware Verification (MANDATORY IN PROD/FORTRESS)