@atlasnomos/atlas 1.1.14 → 10.0.1

package/src/enforcement/RuntimeSandbox.js

@@ -21,6 +21,97 @@ const { execSync, spawn } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 const { BlockError } = require('./PipelinePrimitives');
+const SentinelInterface = require('../kernel/constitution/SentinelInterface');
+
+// Hash-chained audit log for SANDBOX_VIOLATION events
+let HashChainedLog = null;
+let _sandboxEventLog = null;
+const SANDBOX_EVENT_LOG_PATH = path.join(process.cwd(), '.atlas', 'audit', 'sandbox_events.chainlog');
+
+function getSandboxEventLog() {
+    if (!HashChainedLog) {
+        try {
+            HashChainedLog = require('../kernel/io/HashChainedLog').HashChainedLog;
+        } catch (e) {
+            return null;
+        }
+    }
+    if (!_sandboxEventLog) {
+        _sandboxEventLog = new HashChainedLog(SANDBOX_EVENT_LOG_PATH, {
+            name: 'SandboxEventLog',
+            panicOnFailure: false
+        });
+        try {
+            _sandboxEventLog.initialize();
+        } catch (e) {
+            return null;
+        }
+    }
+    return _sandboxEventLog;
+}
+
+/**
+ * Emit SANDBOX_VIOLATION event to hash-chained audit log
+ * @param {string} violationType - Type of violation (NETWORK, FILESYSTEM, TIMEOUT, etc.)
+ * @param {Object} details - Violation details
+ */
+function emitSandboxViolation(violationType, details) {
+    const log = getSandboxEventLog();
+    if (log) {
+        try {
+            const entry = log.append({
+                event: 'SANDBOX_VIOLATION',
+                timestamp: new Date().toISOString(),
+                violation_type: violationType,
+                tier: process.env.SENTINEL_TIER || 'DEV',
+                action: 'BLOCK',
+                ...details
+            });
+
+            // PROD HARDENING: Anchor to main audit chain
+            try {
+                const Sentinel = SentinelInterface.SentinelInterface || SentinelInterface;
+                if (Sentinel.getInstance) {
+                    Sentinel.getInstance().logAnchor('SandboxEventLog', entry.hash, entry.seq);
+                }
+            } catch (anchorErr) {
+                // Non-fatal
+            }
+        } catch (e) {
+            console.error('[RuntimeSandbox] Failed to emit SANDBOX_VIOLATION:', e.message);
+        }
+    }
+}
+
+
+/**
+ * H-03 FIX: Emit positive execution evidence ("Dark Matter" coverage).
+ * @param {Object} details - Execution details
+ */
+function emitSandboxExecutionComplete(details) {
+    const log = getSandboxEventLog();
+    if (log) {
+        try {
+            const entry = log.append({
+                event: 'SANDBOX_EXECUTION_COMPLETE',
+                timestamp: new Date().toISOString(),
+                ...details
+            });
+
+            // Anchor to main chain
+            try {
+                const Sentinel = SentinelInterface.SentinelInterface || SentinelInterface;
+                if (Sentinel.getInstance) {
+                    Sentinel.getInstance().logAnchor('SandboxEventLog', entry.hash, entry.seq);
+                }
+            } catch (anchorErr) {
+                // Non-fatal
+            }
+        } catch (e) {
+            console.error('[RuntimeSandbox] Failed to emit SANDBOX_EXECUTION_COMPLETE:', e.message);
+        }
+    }
+}
 
 // ═══════════════════════════════════════════════════════════════
 // CONFIGURATION
@@ -46,11 +137,11 @@ const DOCKER_IMAGES = {
     rust: 'rust:1.75-alpine'
 };
 
-// Mocked API templates per language (v8.1 Enhanced)
+// Mocked API templates per language (v8.1 Enhanced + H-01 Deterministic Seeding)
 const MOCKED_APIS = {
-    javascript: `
+    javascript: (seed) => `
 // ATLAS Sandbox: Mocked APIs for Deterministic Execution
-const ATLAS_SEED = ${Date.now()};
+const ATLAS_SEED = ${seed};
 let randomCounter = 0;
 
 // Mock Date to fixed timestamp
@@ -95,14 +186,14 @@ require('fs').writeFileSync = function(filepath, ...args) {
     return originalWriteFileSync(filepath, ...args);
 };
 `,
-    python: `
+    python: (seed) => `
 # ATLAS Sandbox: Mocked APIs for Deterministic Execution
 import time
 import random
 import sys
 from datetime import datetime
 
-ATLAS_SEED = ${Date.now()}
+ATLAS_SEED = ${seed}
 random_counter = 0
 
 # Mock time.time() to fixed timestamp
@@ -131,7 +222,7 @@ def _mocked_open(filepath, mode='r', *args, **kwargs):
     return _original_open(filepath, mode, *args, **kwargs)
 builtins.open = _mocked_open
 `,
-    java: `
+    java: (seed) => `
 // ATLAS Sandbox: Mocked APIs for Deterministic Execution
 import java.io.*;
 import java.util.*;
@@ -139,7 +230,7 @@ import java.net.*;
 import java.nio.file.*;
 
 public class AtlasSandbox {
-    public static final long ATLAS_SEED = ${Date.now()}L;
+    public static final long ATLAS_SEED = ${seed}L;
     private static int randomCounter = 0;
     
     static {
@@ -179,7 +270,7 @@ public class AtlasSandbox {
     }
 }
 `,
-    go: `
+    go: (seed) => `
 // ATLAS Sandbox: Mocked APIs for Deterministic Execution
 package main
 
@@ -190,7 +281,7 @@ import (
     "os"
 )
 
-const ATLAS_SEED int64 = ${Date.now()}
+const ATLAS_SEED int64 = ${seed}
 var randomCounter int = 0
 
 func init() {
@@ -217,12 +308,12 @@ func atlasTime() time.Time {
     return time.Unix(ATLAS_SEED/1000, 0)
 }
 `,
-    rust: `
+    rust: (seed) => `
 // ATLAS Sandbox: Mocked APIs for Deterministic Execution
 use std::time::{SystemTime, UNIX_EPOCH, Duration};
 use std::f64;
 
-const ATLAS_SEED: i64 = ${Date.now()};
+const ATLAS_SEED: i64 = ${seed};
 static mut RANDOM_COUNTER: i32 = 0;
 
 // Mock SystemTime::now()
@@ -310,13 +401,20 @@ class RuntimeSandbox {
     /**
      * Prepare code for sandboxed execution.
      * Injects mocked APIs based on language.
+     * @param {string} code - User code
+     * @param {string} language - Language
+     * @param {string} entrypoint - Entry point code
+     * @param {number} seed - Deterministic seed (H-01 FIX)
      */
-    prepareCode(code, language, entrypoint) {
-        const mockedApi = MOCKED_APIS[language];
-        if (!mockedApi) {
+    prepareCode(code, language, entrypoint, seed) {
+        const mockedApiFn = MOCKED_APIS[language];
+        if (!mockedApiFn) {
             throw new Error(`Unsupported language for sandbox: ${language}`);
         }
 
+        // Generate mocked API with deterministic seed
+        const mockedApi = mockedApiFn(seed);
+
         // Inject mocked APIs at the beginning
         const preparedCode = mockedApi + '\n\n' + code;
 
@@ -395,16 +493,29 @@ fn main() {
     /**
      * Execute code in Docker sandbox.
      * 
-     * Returns: { 
-     *   success, 
-     *   stdout, 
-     *   stderr, 
-     *   exitCode, 
-     *   execution_hash,
-     *   execution_time_ms 
-     * }
+     * @param {string} code - Code to execute
+     * @param {string} language - Language
+     * @param {string} entrypoint - Entry point
+     * @param {string} input - Input
+     * @param {Object} provenance - R-02 PROVENANCE (Required in PROD)
+     * @param {string} provenance.approval_hash
+     * @param {string} provenance.policy_hash
+     * 
+     * Returns: { ... }
      */
-    async execute(code, language, entrypoint = '', input = '') {
+    async execute(code, language, entrypoint = '', input = '', provenance = null) {
+        // R-02 FIX: Enforce Provenance Binding in PROD
+        // "EXECUTION must reference exactly one approval + policy"
+        if (process.env.SENTINEL_TIER !== 'DEV' && process.env.SENTINEL_TIER !== 'TEST') {
+            if (!provenance || !provenance.approval_hash || !provenance.policy_hash) {
+                const { panic } = require('../kernel/boot/HardKill'); // Lazy load
+                panic('EXECUTION_WITHOUT_PROVENANCE', {
+                    reason: 'PROD execution requires explicit approval + policy binding',
+                    language,
+                    input_summary: input.substring(0, 32)
+                });
+            }
+        }
         // Check Docker availability
         const dockerCheck = this.checkDocker();
         if (!dockerCheck.available) {
@@ -427,8 +538,15 @@ fn main() {
             };
         }
 
-        // Prepare code with mocked APIs
-        const preparedCode = this.prepareCode(code, language, entrypoint);
+        // H-01 FIX: Deterministic Seed Derivation
+        // Seed = SHA256(Input + Code)[0..48] -> integer
+        // Eliminates "Seed-Gap" by binding entropy to input content.
+        const seedPayload = input + code;
+        const seedHash = crypto.createHash('sha256').update(seedPayload).digest('hex');
+        const seed = parseInt(seedHash.substring(0, 13), 16); // Safe integer range
+
+        // Prepare code with mocked APIs and deterministic seed
+        const preparedCode = this.prepareCode(code, language, entrypoint, seed);
 
         // Create temporary directory for execution
         const tempDir = path.join(this.outputDir, `exec-${Date.now()}`);
@@ -581,10 +699,21 @@ fn main() {
                     execution_hash: executionHash,
                     execution_time_ms: executionTimeMs,
                     resource_profile: resourceProfile, // v8.1
-                    blocked: !success,
                     reason: success ? null : 'SANDBOX_EXECUTION_FAILED'
                 };
 
+                // H-03 FIX: Positive Execution Evidence
+                if (success) {
+                    emitSandboxExecutionComplete({
+                        execution_hash: executionHash,
+                        execution_time_ms: executionTimeMs,
+                        resource_summary: resourceProfile || { estimated_ms: executionTimeMs },
+                        tier: process.env.SENTINEL_TIER || 'DEV',
+                        // R-02: Bind Provenance to Evidence
+                        provenance: provenance || { warning: 'NO_PROVENANCE_PROVIDED' }
+                    });
+                }
+
                 // v8.1: Store in execution history for replay
                 this.executionHistory.push({
                     timestamp: new Date().toISOString(),

package/src/interface/cli/commands/BuildCommand.js

@@ -29,6 +29,16 @@ class BuildCommand {
             return { success: false };
         }
 
+        // INSTRUMENTATION: Audit Sink (Platform Bridge)
+        const { getAuditSink } = require('../../../kernel/io/AuditSink');
+        const auditSink = getAuditSink();
+        // Reserve execution ID (Emits RUN_STARTED)
+        const reservationId = auditSink.reserve({
+            tool: 'atlas-build',
+            tenantId: process.env.SENTINEL_TENANT_ID || 'local-dev',
+            executionId: trace?.id || `build_${Date.now()}`
+        });
+
         // AUTO-HEALING: Capture pre-build snapshot for recovery
         await SelfHealEngine.captureSnapshot();
         const { getInstance: getSession } = require('../../../core/SessionContext');
@@ -38,48 +48,58 @@ class BuildCommand {
         console.log(`  ATLAS BUILD — Full Pipeline (Session: ${session.getId().substring(0, 8)})`);
         console.log('═══════════════════════════════════════════════════════════\n');
 
-        // 0. PREFLIGHT: Environment & Credential Check (UX Optimization)
-        this._validateEnvironment();
-
-        // NOTE: Removed ATLAS_HARDWARE_TOKEN check - local env vars are not security controls
-        // Only Sentinel authorization provides security guarantees
-
-        const { getInstance: getSentinel } = require('../../../kernel/constitution/SentinelInterface');
-        const sentinel = getSentinel();
-        if (!await sentinel.isHealthy()) {
-            console.error('❌ Sentinel Unreachable. Build Aborted (Fail-Closed).');
-            return { success: false, reason: 'Sentinel Unreachable' };
-        }
+        try {
+            // 0. PREFLIGHT: Environment & Credential Check (UX Optimization)
+            this._validateEnvironment();
+
+            // NOTE: Removed ATLAS_HARDWARE_TOKEN check - local env vars are not security controls
+            // Only Sentinel authorization provides security guarantees
+
+            const { getInstance: getSentinel } = require('../../../kernel/constitution/SentinelInterface');
+            const sentinel = getSentinel();
+            if (!await sentinel.isHealthy()) {
+                console.error('❌ Sentinel Unreachable. Build Aborted (Fail-Closed).');
+                auditSink.abandon(reservationId, 'Sentinel Unreachable');
+                return { success: false, reason: 'Sentinel Unreachable' };
+            }
 
-        const crypto = require('crypto');
-        const goalHash = crypto.createHash('sha256').update(goal).digest('hex');
+            const crypto = require('crypto');
+            const goalHash = crypto.createHash('sha256').update(goal).digest('hex');
 
-        const traceId = trace?.id || `build_${Date.now()}`;
-        const approved = await sentinel.requestApproval(traceId, 'BUILD_PROJECT', {
-            goal,
-            goal_hash: goalHash,
-            user: process.env.USERNAME || 'operator',
-            session_id: session.getId()
-        });
+            const traceId = reservationId; // Use reservation ID as trace ID for consistency
+            const approved = await sentinel.requestApproval(traceId, 'BUILD_PROJECT', {
+                goal,
+                goal_hash: goalHash,
+                user: process.env.USERNAME || 'operator',
+                session_id: session.getId()
+            });
 
-        if (!approved.approved && !approved.locally_permitted) {
-            console.error('⛔ Build DENIED by Sentinel Policy.');
-            return { success: false, reason: 'Sentinel Denied' };
-        }
+            // INSTRUMENTATION: Record Decision (Emits DECISION_MADE)
+            auditSink.recordDecision(
+                reservationId,
+                approved.approved || approved.locally_permitted ? 'AUTHORIZED' : 'BLOCKED',
+                'POLICY-BUILD-001',
+                approved.attested ? (approved.token?.key_id || 'sentinel-key') : 'local-dev-key'
+            );
+
+            if (!approved.approved && !approved.locally_permitted) {
+                console.error('⛔ Build DENIED by Sentinel Policy.');
+                auditSink.abandon(reservationId, 'Sentinel Denied');
+                return { success: false, reason: 'Sentinel Denied' };
+            }
 
 
-        // V2: Display attestation status
-        if (approved.attested) {
-            console.log('✅ Sentinel Approved (ATTESTED). Proceeding with Build Pipeline.\n');
-        } else if (approved.locally_permitted) {
-            console.log('⚠️  Local Governance Active (UNATTESTED). Proceeding locally.\n');
-        } else {
-            console.log('✅ Sentinel Approved (NON-ATTESTED). Proceeding in ' + this.tierManager.getTier() + ' mode.\n');
-        }
+            // V2: Display attestation status
+            if (approved.attested) {
+                console.log('✅ Sentinel Approved (ATTESTED). Proceeding with Build Pipeline.\n');
+            } else if (approved.locally_permitted) {
+                console.log('⚠️  Local Governance Active (UNATTESTED). Proceeding locally.\n');
+            } else {
+                console.log('✅ Sentinel Approved (NON-ATTESTED). Proceeding in ' + this.tierManager.getTier() + ' mode.\n');
+            }
 
-        console.log('🧠 Engaging Hive Mind (Ring-2 Process B)...');
+            console.log('🧠 Engaging Hive Mind (Ring-2 Process B)...');
 
-        try {
             // 1. PLANNING
             console.log('📋 PlannerAgent Active. Decomposing Goal...');
 
@@ -93,6 +113,7 @@ class BuildCommand {
 
             if (!planResult.success || !planResult.plan) {
                 console.error('❌ Planning failed:', planResult.error);
+                auditSink.abandon(reservationId, 'Planning Failed');
                 return { success: false, reason: 'Planning Failed' };
             }
 
@@ -106,6 +127,7 @@ class BuildCommand {
 
             if (!genResult.success) {
                 console.error('❌ Generation failed:', genResult.error);
+                auditSink.abandon(reservationId, 'Generation Failed');
                 return { success: false, reason: 'Generation Failed' };
             }
 
@@ -195,12 +217,14 @@ class BuildCommand {
 
             if (!commitApproval.approved && !commitApproval.locally_permitted) {
                 console.error('⛔ COMMIT DENIED by Sentinel. Integrity check failed or unauthorized.');
+                auditSink.abandon(reservationId, 'Commit Denied');
                 return { success: false, reason: 'Commit Denied' };
             }
 
             // Verify the signature on the commit matches the hash [Only in attested mode]
             if (commitApproval.attested && commitApproval.payload.metadata?.artifact_hash !== artifactHash) {
                 console.error('❌ CRITICAL: Sentinel signed a DIFFERENT hash than our candidate! Possible interception.');
+                auditSink.abandon(reservationId, 'Integrity Mismatch');
                 return { success: false, reason: 'Integrity Mismatch' };
             }
 
@@ -288,6 +312,14 @@ class BuildCommand {
                 // V2: Display attestation summary
                 this.attestationManager.displayResult(commitApproval);
 
+                // INSTRUMENTATION: Complete Audit
+                auditSink.complete(reservationId, {
+                    result: 'SUCCESS',
+                    cost: 0,
+                    model: 'mcp-router',
+                    role: 'builder'
+                });
+
                 return { success: true, attested: commitApproval.attested };
 
             } catch (persistError) {
@@ -298,6 +330,7 @@ class BuildCommand {
 
         } catch (e) {
             console.error('❌ Agent Execution Protocol Failed:', e.message);
+            auditSink.abandon(reservationId, `Agent Crash: ${e.message}`);
             return { success: false, reason: 'Agent Crash' };
         }
     }

package/src/kernel/automation/AutomationRegistry.js

@@ -0,0 +1,159 @@
+/**
+ * ATLAS v10 — Automation Registry (AURORA)
+ * 
+ * PURPOSE: Load and maintain active Automation Grants.
+ * 
+ * SECURITY INVARIANTS:
+ * - PROD-ONLY: Construction throws in DEV.
+ * - Immutable: Grants cannot be added at runtime (except via Sentinel Push - future).
+ * - Verified: All loaded grants must pass Sentinel Signature check.
+ * 
+ * @module kernel/automation/AutomationRegistry
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { getActiveMode, isProdOrHigher } = require('../modes/ActiveMode');
+const { panic } = require('../boot/HardKill');
+const SentinelInterface = require('../constitution/SentinelInterface');
+const { AUTOMATION_EVENTS } = require('./AutomationSchema');
+
+const GRANTS_PATH = path.join(process.cwd(), '.atlas', 'automation', 'grants.json');
+
+class AutomationRegistry {
+    constructor() {
+        // INVARIANT: Registry is PROD-only
+        if (!isProdOrHigher()) {
+            throw new Error('DEV_MODE_VIOLATION: AutomationRegistry cannot be instantiated in DEV.');
+        }
+
+        this._grants = new Map(); // grant_id -> Grant
+        this._initialized = false;
+    }
+
+    /**
+     * Initialize registry by loading grants from trusted storage.
+     * @returns {Promise<void>}
+     */
+    async initialize() {
+        if (this._initialized) return;
+
+        if (!fs.existsSync(GRANTS_PATH)) {
+            // No grants file implies no automation. That's fine.
+            this._initialized = true;
+            return;
+        }
+
+        let rawGrants = [];
+        try {
+            rawGrants = JSON.parse(fs.readFileSync(GRANTS_PATH, 'utf8'));
+        } catch (e) {
+            panic('AUTOMATION_CONFIG_CORRUPT', { error: e.message });
+        }
+
+        if (!Array.isArray(rawGrants)) {
+            panic('AUTOMATION_CONFIG_INVALID', { reason: 'Root must be array' });
+        }
+
+        const sentinel = SentinelInterface.getInstance();
+
+        for (const grant of rawGrants) {
+            // 1. Verify Trust
+            const valid = await sentinel.verifyAutomationGrant(grant);
+            if (!valid) {
+                panic('AUTOMATION_GRANT_INVALID', { grantId: grant.grant_id });
+            }
+
+            // 2. Check Expiry
+            const now = new Date();
+            const expiresAt = new Date(grant.expires_at);
+            if (now > expiresAt) {
+                console.warn(`[Automation] Skipping expired grant: ${grant.grant_id}`);
+                continue;
+            }
+
+            // 3. Register
+            this._grants.set(grant.grant_id, Object.freeze(grant));
+
+            // 4. Log Event
+            sentinel.logAudit({
+                event: AUTOMATION_EVENTS.REGISTERED,
+                grantId: grant.grant_id,
+                scope: grant.scope
+            });
+        }
+
+        // 5. Compute Merkle Root (Registry Sealing)
+        // Sort grant IDs to ensure deterministic root
+        const sortedIds = Array.from(this._grants.keys()).sort();
+        const grantHashes = sortedIds.map(id => {
+            const grant = this._grants.get(id);
+            // Hash GrantID + Signature for binding
+            return crypto.createHash('sha256')
+                .update(`${grant.grant_id}:${grant.sentinel_signature}`)
+                .digest('hex');
+        });
+
+        const merkleRoot = grantHashes.reduce((root, hash) => {
+            return crypto.createHash('sha256').update(root + hash).digest('hex');
+        }, '0000000000000000000000000000000000000000000000000000000000000000'); // Genesis Zero
+
+        // 6. Seal Registry
+        sentinel.logAudit({
+            event: 'AUTOMATION_REGISTRY_SEALED',
+            active_grants: this._grants.size,
+            merkle_root: merkleRoot,
+            timestamp: new Date().toISOString()
+        });
+
+        console.log(`[AutomationRegistry] Initialized with ${this._grants.size} active grants. Registry Sealed.`);
+
+        // v10.2: Emit AUTHORITY_SNAPSHOT (Snapshot Authority Model)
+        // Grants are valid for session lifetime. Revocation applies at next boot.
+        sentinel.logAudit({
+            event: 'AUTOMATION_AUTHORITY_SNAPSHOT',
+            active_grants: this._grants.size,
+            grant_ids: Array.from(this._grants.keys()),
+            merkle_root: merkleRoot,
+            session_id: `BOOT_${Date.now()}`,
+            model: 'SNAPSHOT', // Revocation applies next boot
+            timestamp: new Date().toISOString()
+        });
+
+        this._initialized = true;
+    }
+
+    /**
+     * Get a grant by ID.
+     * @param {string} grantId 
+     * @returns {Object|undefined}
+     */
+    getGrant(grantId) {
+        return this._grants.get(grantId);
+    }
+
+    /**
+     * list active grants (for Verifier)
+     */
+    getAllGrants() {
+        return Array.from(this._grants.values());
+    }
+}
+
+// Singleton (Lazy)
+let _instance = null;
+
+function getInstance() {
+    if (!_instance) {
+        if (isProdOrHigher()) {
+            _instance = new AutomationRegistry();
+        } else {
+            // In DEV, accessing the instance is a violation
+            throw new Error('DEV_MODE_VIOLATION: Accessing AutomationRegistry in DEV');
+        }
+    }
+    return _instance;
+}
+
+module.exports = { AutomationRegistry, getInstance };