arcvision 0.2.20 → 0.2.21

package/.arcvision/logs/errors.log

@@ -3,3 +3,5 @@
 {"timestamp":"2026-01-25T02:04:57.719Z","error":{"category":"UNKNOWN","message":"Invalid ledger structure","code":null,"type":"Error"},"context":{"operation":"evaluate","directory":"C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\test-dev-project"},"stack":"Error: Invalid ledger structure\n    at AuthorityLedger.readLedger (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\core\\authority-ledger.js:203:15)\n    at AuthorityLedger.appendEvent (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\core\\authority-ledger.js:176:27)\n    at AuthorityLedger.recordBlocked (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\core\\authority-ledger.js:81:10)\n    at Command.<anonymous> (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\index.js:662:35)\n    at process.processTicksAndRejections (node:internal/process/task_queues:95:5)"}
 {"timestamp":"2026-01-25T02:05:38.566Z","error":{"category":"UNKNOWN","message":"Invalid ledger structure","code":null,"type":"Error"},"context":{"operation":"evaluate","directory":"C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\test-dev-project"},"stack":"Error: Invalid ledger structure\n    at AuthorityLedger.readLedger (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\core\\authority-ledger.js:203:15)\n    at AuthorityLedger.appendEvent (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\core\\authority-ledger.js:176:27)\n    at AuthorityLedger.recordBlocked (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\core\\authority-ledger.js:81:10)\n    at Command.<anonymous> (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\index.js:662:35)\n    at process.processTicksAndRejections (node:internal/process/task_queues:95:5)"}
 {"timestamp":"2026-01-25T03:16:17.596Z","error":{"category":"CONFIGURATION","message":"Invalid or revoked token","code":null,"type":"Error"},"context":{"operation":"standard_upload"},"stack":"Error: Invalid or revoked token\n    at C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\index.js:330:19\n    at process.processTicksAndRejections (node:internal/process/task_queues:95:5)\n    at async RetryHandler.executeWithRetry (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\core\\retry-handler.js:23:24)\n    at async uploadToDatabase (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\index.js:294:24)\n    at async Command.<anonymous> (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\index.js:462:9)"}
+{"timestamp":"2026-01-25T10:28:14.750Z","error":{"category":"UNKNOWN","message":"Failed to initiate upload session","code":null,"type":"Error"},"context":{"operation":"chunked_upload"},"stack":"Error: Failed to initiate upload session\n    at ChunkedUploader.uploadInChunks (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\core\\chunked-uploader.js:58:13)\n    at process.processTicksAndRejections (node:internal/process/task_queues:95:5)\n    at async C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\index.js:177:18\n    at async RetryHandler.executeWithRetry (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\core\\retry-handler.js:23:24)\n    at async uploadToDatabase (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\index.js:176:24)\n    at async Command.<anonymous> (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\index.js:473:9)"}
+{"timestamp":"2026-01-25T14:09:23.628Z","error":{"category":"CONFIGURATION","message":"Invalid or revoked token","code":null,"type":"Error"},"context":{"operation":"standard_upload"},"stack":"Error: Invalid or revoked token\n    at C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\index.js:341:19\n    at process.processTicksAndRejections (node:internal/process/task_queues:95:5)\n    at async RetryHandler.executeWithRetry (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\core\\retry-handler.js:23:24)\n    at async uploadToDatabase (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\index.js:294:24)\n    at async Command.<anonymous> (C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\index.js:473:9)"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arcvision",
-  "version": "0.2.20",
+  "version": "0.2.21",
   "description": "ArcVision CLI - Architectural Governance and Invariant Detection Tool",
   "main": "src/index.js",
   "bin": {

package/src/arcvision-guard.js

@@ -206,11 +206,17 @@ program
       fs.mkdirSync(tokensDir, { recursive: true });
     }
     
-    // Copy configuration templates
-    const templateDir = path.join(__dirname, '..', '.arcvision');
-    if (fs.existsSync(templateDir)) {
-      copyFile(path.join(templateDir, 'config.json'), path.join(arcDir, 'config.json'));
-      copyFile(path.join(templateDir, 'invariants.json'), path.join(arcDir, 'invariants.json'));
+    // Create default configuration (no longer using separate invariants file as they're stored in context)
+    const configPath = path.join(arcDir, 'config.json');
+    if (!fs.existsSync(configPath)) {
+      const defaultConfig = {
+        guard_rules: {
+          blast_radius: {
+            critical_threshold: 50
+          }
+        }
+      };
+      fs.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2));
       console.log(chalk.green('✅ Configuration files created'));
     }
     
@@ -223,7 +229,7 @@ program
     console.log(chalk.green('\n🎉 ArcVision Impact Guard initialized successfully!'));
     console.log(chalk.yellow('\nNext steps:'));
     console.log(chalk.yellow('1. Review .arcvision/config.json for project settings'));
-    console.log(chalk.yellow('2. Customize .arcvision/invariants.json with your architectural rules'));
+    console.log(chalk.yellow('2. Auto-detect architectural invariants by running: arcvision scan'));
     console.log(chalk.yellow('3. Run: arcvision-guard check'));
     console.log(chalk.yellow('4. For critical changes: arcvision-guard bypass-request --reason "your reason"'));
   });
@@ -246,17 +252,11 @@ program
       remediation: "Define appropriate remediation steps"
     };
     
-    const invariantsPath = path.join('.arcvision', 'invariants.json');
-    if (!fs.existsSync(invariantsPath)) {
-      console.log(chalk.red('❌ ArcVision not initialized. Run "arcvision-guard setup" first.'));
-      process.exit(1);
-    }
-    
-    const invariants = JSON.parse(fs.readFileSync(invariantsPath, 'utf8'));
-    invariants.project_specific_invariants.push(invariant);
-    
-    fs.writeFileSync(invariantsPath, JSON.stringify(invariants, null, 2));
-    console.log(chalk.green(`✅ Added invariant: ${name}`));
+    // Note: Invariants are now automatically detected by scanning and stored in arcvision.context.json
+    console.log(chalk.red('❌ Custom invariants are now managed differently.'));
+    console.log(chalk.yellow('💡 Run "arcvision scan" to auto-detect invariants from your codebase.'));
+    console.log(chalk.yellow('💡 Or manually edit the invariants section in arcvision_context/arcvision.context.json if needed.'));
+    process.exit(1);
   });
 
 // Helper functions

package/src/core/artifact-manager.js

@@ -4,11 +4,12 @@ const path = require('path');
 class ArtifactManager {
   constructor(projectRoot) {
     this.projectRoot = projectRoot;
-    this.requiredDirs = ['.arcvision', 'arcvision_context'];
+    // Remove .arcvision directory as invariants should be in main context file only
+    this.requiredDirs = ['arcvision_context'];
     this.requiredFiles = {
       context: 'arcvision_context/arcvision.context.json',
-      ledger: 'arcvision_context/architecture.authority.ledger.json',
-      invariants: '.arcvision/invariants.json'
+      ledger: 'arcvision_context/architecture.authority.ledger.json'
+      // Remove invariants from separate file as they should be in main context per schema
     };
   }
 
@@ -43,19 +44,6 @@ class ArtifactManager {
    * Creates missing files with default content
    */
   createMissingFiles() {
-    // Create default invariants file if missing
-    const invariantsPath = path.join(this.projectRoot, this.requiredFiles.invariants);
-    if (!fs.existsSync(invariantsPath)) {
-      const defaultInvariants = {
-        version: '1.0',
-        project_specific_invariants: [],
-        generated_at: new Date().toISOString()
-      };
-      
-      fs.writeFileSync(invariantsPath, JSON.stringify(defaultInvariants, null, 2));
-      this.logCreation(this.requiredFiles.invariants);
-    }
-
     // Create default ledger if missing
     const ledgerPath = path.join(this.projectRoot, this.requiredFiles.ledger);
     if (!fs.existsSync(ledgerPath)) {

package/src/core/config-validator.js

@@ -7,13 +7,13 @@ class ConfigValidator {
    */
   static validateProjectStructure(projectPath) {
     const requiredPaths = [
-      path.join(projectPath, 'arcvision_context'),
-      path.join(projectPath, '.arcvision')
+      path.join(projectPath, 'arcvision_context')
+      // Removed .arcvision as invariants are now stored in main context file
     ];
     
     const optionalPaths = [
       path.join(projectPath, 'arcvision_context', 'arcvision.context.json'),
-      path.join(projectPath, '.arcvision', 'invariants.json'),
+      // Removed .arcvision/invariants.json as invariants are now stored in main context file
       path.join(projectPath, 'arcvision_context', 'architecture.authority.ledger.json')
     ];
     
@@ -174,14 +174,7 @@ class ConfigValidator {
       isValid: projectValidation.isValid
     };
     
-    // Validate invariants file if it exists
-    const invariantsPath = path.join(projectPath, '.arcvision', 'invariants.json');
-    if (fs.existsSync(invariantsPath)) {
-      configValidation.invariantsFile = this.validateInvariantsFile(invariantsPath);
-      if (!configValidation.invariantsFile.isValid) {
-        configValidation.isValid = false;
-      }
-    }
+    // No longer validating separate invariants file as they are stored in main context file
     
     // Validate context file if it exists
     const contextPath = path.join(projectPath, 'arcvision_context', 'arcvision.context.json');

package/src/core/context_builder.js

@@ -190,8 +190,9 @@ function buildContext(fileNodes, edges, symbols, options = {}) {
         structural_hubs: options.structuralHubs || [],
         architectural_boundaries: options.architecturalBoundaries || {},
         structural_invariants: options.structuralInvariants || [],
-        // Include detected invariants from the current scan
-        invariants: options.detectedInvariants || [],
+        // Include detected invariants from the current scan - these should conform to the schema specification
+        invariants: Array.isArray(options.autoDetectedInvariants) ? options.autoDetectedInvariants : 
+                   Array.isArray(options.detectedInvariants) ? options.detectedInvariants : [],
         // Include invariant analysis results
         invariant_analysis: options.invariantAnalysis || null,
         // Include architectural health assessment

package/src/core/feature-manager.js

@@ -30,9 +30,23 @@ class FeatureManager {
    * Checks for the presence of key artifacts
    */
   static checkArtifacts(projectPath) {
+    // Read the context file to check if it contains invariants
+    const contextPath = path.join(projectPath, 'arcvision_context', 'arcvision.context.json');
+    let invariantsExists = false;
+    
+    if (fs.existsSync(contextPath)) {
+      try {
+        const contextData = JSON.parse(fs.readFileSync(contextPath, 'utf8'));
+        invariantsExists = Array.isArray(contextData.invariants) && contextData.invariants.length > 0;
+      } catch (error) {
+        // If there's an error parsing, assume no invariants
+        invariantsExists = false;
+      }
+    }
+    
     return {
-      context_exists: fs.existsSync(path.join(projectPath, 'arcvision_context', 'arcvision.context.json')),
-      invariants_exists: fs.existsSync(path.join(projectPath, '.arcvision', 'invariants.json')),
+      context_exists: fs.existsSync(contextPath),
+      invariants_exists: invariantsExists,
       ledger_exists: fs.existsSync(path.join(projectPath, 'arcvision_context', 'architecture.authority.ledger.json')),
       readme_exists: fs.existsSync(path.join(projectPath, 'arcvision_context', 'README.md')),
       arcvision_dir_exists: fs.existsSync(path.join(projectPath, '.arcvision')),
@@ -51,9 +65,9 @@ class FeatureManager {
       recommendations.push({
         type: 'SETUP',
         priority: 'HIGH',
-        message: 'Define architectural invariants for governance',
-        action: 'arcvision init-invariants',
-        description: 'Create custom rules to govern your architectural decisions'
+        message: 'Auto-detect architectural invariants for governance',
+        action: 'arcvision scan',
+        description: 'Re-scan your project to auto-detect architectural invariants'
       });
     }
 

package/src/core/invariant-detector.js

@@ -61,16 +61,18 @@ class InvariantDetector {
               system: 'automatic',
               statement: invariant.description,
               description: invariant.description,
-              severity: invariant.isCritical ? 'block' : 'risk',
               scope: { files: [nodeId] },
               critical_path: invariant.isCritical,
               assertion: `Pattern: ${invariant.pattern}`,
+              status: 'suspected',
+              confidence: this.calculateConfidenceScore(invariant.pattern, nodeId, content),
+              owner: this.determineOwnerFromPath(nodeId),
+              violated_by: [],
+              severity: invariant.isCritical ? 'block' : 'risk',
               rule: {
                 type: 'pattern',
                 condition: { pattern: invariant.pattern }
               },
-              status: 'suspected',
-              confidence: this.calculateConfidenceScore(invariant.pattern, nodeId, content),
               source_file: nodeId,
               detected_at: new Date().toISOString()
             });
@@ -96,10 +98,14 @@ class InvariantDetector {
         system: 'automatic',
         statement: constraint.description,
         description: constraint.description,
-        severity: constraint.critical ? 'block' : 'risk',
         scope: { files: [constraint.from, constraint.to] },
         critical_path: constraint.critical,
         assertion: `Dependency constraint: ${constraint.from} -> ${constraint.to}`,
+        status: 'suspected',
+        confidence: this.calculateConfidenceScore('dependency_constraint', constraint.from, ''),
+        owner: this.determineOwnerFromPath(constraint.from),
+        violated_by: [],
+        severity: constraint.critical ? 'block' : 'risk',
         rule: {
           type: 'dependency',
           condition: {
@@ -109,8 +115,6 @@ class InvariantDetector {
             }
           }
         },
-        status: 'suspected',
-        confidence: this.calculateConfidenceScore('dependency_constraint', constraint.from, ''),
         source_relationship: `${constraint.from} -> ${constraint.to}`,
         detected_at: new Date().toISOString()
       });
@@ -137,16 +141,18 @@ class InvariantDetector {
             system: 'automatic',
             statement: `System invariant implemented in ${relativePath}: ${pattern.description}`,
             description: `System invariant implemented in ${relativePath}: ${pattern.description}`,
-            severity: 'risk',
             scope: { files: [relativePath] },
             critical_path: true,  // File specifically for invariants is likely critical
             assertion: pattern.assertion,
+            status: 'suspected',
+            confidence: this.calculateConfidenceScore(pattern.type, relativePath, content),
+            owner: this.determineOwnerFromPath(relativePath),
+            violated_by: [],
+            severity: 'risk',
             rule: {
               type: 'pattern',
               condition: { pattern: pattern.type }
             },
-            status: 'suspected',
-            confidence: this.calculateConfidenceScore(pattern.type, relativePath, content),
             source_file: relativePath,
             implementation_type: pattern.type,
             detected_at: new Date().toISOString()
@@ -664,10 +670,14 @@ class InvariantDetector {
           system: 'architectural',
           statement: `Layer dependency rule: ${fromLayer} components should not depend on ${toLayer} components`,
           description: `Prevent ${fromLayer} layer from depending on ${toLayer} layer to maintain separation of concerns`,
-          severity: 'block',
           scope: { files: dependencies.map(d => d.from) },
           critical_path: true,
           assertion: `Layer dependency rule: ${fromLayer} -> ${toLayer} is forbidden`,
+          status: 'detected',
+          confidence: 0.9,
+          owner: 'architectural-analyzer',
+          violated_by: [],
+          severity: 'block',
           rule: {
             type: 'dependency',
             condition: {
@@ -677,8 +687,6 @@ class InvariantDetector {
               }
             }
           },
-          status: 'detected',
-          confidence: 0.9,
           detected_at: new Date().toISOString()
         });
       }
@@ -707,26 +715,31 @@ class InvariantDetector {
     
     // Identify potential architectural bottlenecks
     for (const [nodeId, degrees] of nodeDegrees.entries()) {
-      if (degrees.incoming > 10) { // High incoming degree indicates hub
-        this.detectedInvariants.push({
-          id: this.generateInvariantId(`hub_protection_${nodeId}`, 'high_degree'),
-          system: 'architectural',
-          statement: `Protect high-degree node ${nodeId} from unauthorized modifications`,
-          description: `Node ${nodeId} has ${degrees.incoming} incoming dependencies, changes here affect many components`,
-          severity: 'risk',
-          scope: { files: [nodeId] },
-          critical_path: true,
-          assertion: `High-degree node protection: ${nodeId} has ${degrees.incoming} dependencies`,
-          rule: {
-            type: 'access_control',
-            condition: {
-              mustBeReviewed: true
-            }
-          },
-          status: 'detected',
-          confidence: 0.8,
-          detected_at: new Date().toISOString()
-        });
+      // Make sure nodeId is valid before creating invariant
+      if (nodeId && nodeId !== 'undefined' && nodeId !== 'null' && nodeId !== 'unknown' && degrees.incoming > 0) {
+        if (degrees.incoming > 10) { // High incoming degree indicates hub
+          this.detectedInvariants.push({
+            id: this.generateInvariantId(`hub_protection_${nodeId}`, 'high_degree'),
+            system: 'architectural',
+            statement: `Protect high-degree node ${nodeId} from unauthorized modifications`,
+            description: `Node ${nodeId} has ${degrees.incoming} incoming dependencies, changes here affect many components`,
+            scope: { files: [nodeId] },
+            critical_path: true,
+            assertion: `High-degree node protection: ${nodeId} has ${degrees.incoming} dependencies`,
+            status: 'detected',
+            confidence: 0.8,
+            owner: this.determineOwnerFromPath(nodeId),
+            violated_by: [],
+            severity: 'risk',
+            rule: {
+              type: 'access_control',
+              condition: {
+                mustBeReviewed: true
+              }
+            },
+            detected_at: new Date().toISOString()
+          });
+        }
       }
     }
   }
@@ -755,25 +768,30 @@ class InvariantDetector {
     for (const [coupleKey, edgesList] of couplingMap.entries()) {
       const [nodeA, nodeB] = coupleKey.split('|');
       
-      this.detectedInvariants.push({
-        id: this.generateInvariantId(`tight_coupling_${nodeA}_${nodeB}`, 'bidirectional'),
-        system: 'architectural',
-        statement: `Prevent tight coupling between ${nodeA} and ${nodeB}`,
-        description: `Bidirectional dependency detected between ${nodeA} and ${nodeB}, indicating tight coupling`,
-        severity: 'risk',
-        scope: { files: [nodeA, nodeB] },
-        critical_path: false,
-        assertion: `Bidirectional dependency: ${nodeA} <-> ${nodeB}`,
-        rule: {
-          type: 'dependency',
-          condition: {
-            shouldAvoidBidirectional: true
-          }
-        },
-        status: 'detected',
-        confidence: 0.7,
-        detected_at: new Date().toISOString()
-      });
+      // Only create the invariant if both node names are valid and non-empty
+      if (nodeA && nodeA.trim() !== '' && nodeB && nodeB.trim() !== '') {
+        this.detectedInvariants.push({
+          id: this.generateInvariantId(`tight_coupling_${nodeA}_${nodeB}`, 'bidirectional'),
+          system: 'architectural',
+          statement: `Prevent tight coupling between ${nodeA} and ${nodeB}`,
+          description: `Bidirectional dependency detected between ${nodeA} and ${nodeB}, indicating tight coupling`,
+          scope: { files: [nodeA, nodeB] },
+          critical_path: false,
+          assertion: `Bidirectional dependency: ${nodeA} <-> ${nodeB}`,
+          status: 'detected',
+          confidence: 0.7,
+          owner: 'architectural-analyzer',
+          violated_by: [],
+          severity: 'risk',
+          rule: {
+            type: 'dependency',
+            condition: {
+              shouldAvoidBidirectional: true
+            }
+          },
+          detected_at: new Date().toISOString()
+        });
+      }
     }
   }
 }

package/src/core/scanner.js

@@ -195,8 +195,9 @@ async function scan(directory) {
             architecturalBoundaries,
             structuralInvariants,
             authoritativeContext,
-            // Include detected invariants
+            // Include detected invariants - this will be used in context_builder
             autoDetectedInvariants: detectedInvariants,
+            detectedInvariants: detectedInvariants,
             // Include invariant analysis results
             invariantAnalysis,
             // Include architectural health assessment

package/src/index.js

@@ -605,21 +605,48 @@ program
           
       console.log(chalk.green(`✅ Loaded context from: ${contextFile}`));
     
-      // Load invariants
+      // Load invariants from both sources for backward compatibility
       const invariantsFile = options.invariantsFile || path.join(targetDir, '.arcvision', 'invariants.json');
       let loadSuccess = false;
           
+      // First, try to load auto-detected invariants from the main context file
+      const contextFilePath = options.contextFile || path.join(targetDir, 'arcvision_context', 'arcvision.context.json');
+      if (fs.existsSync(contextFilePath)) {
+        try {
+          const contextContent = fs.readFileSync(contextFilePath, 'utf8');
+          const contextData = JSON.parse(contextContent);
+          
+          // Load auto-detected invariants from the context file if they exist
+          if (contextData.invariants && Array.isArray(contextData.invariants) && contextData.invariants.length > 0) {
+            console.log(chalk.blue(`Loading ${contextData.invariants.length} auto-detected invariants from context file...`));
+            
+            // Load each invariant individually to the registry
+            for (const invariant of contextData.invariants) {
+              invariantRegistry.register(invariant);
+            }
+            
+            console.log(chalk.green(`✅ Loaded ${contextData.invariants.length} auto-detected invariants from context file`));
+            loadSuccess = true; // Mark as successful if we loaded from context
+          } else {
+            console.log(chalk.yellow('No auto-detected invariants found in context file'));
+          }
+        } catch (contextError) {
+          console.log(chalk.yellow(`⚠️  Could not load invariants from context file: ${contextError.message}`));
+        }
+      }
+      
+      // Then, try to load project-specific invariants from the separate file (for backward compatibility)
       if (fs.existsSync(invariantsFile)) {
-        loadSuccess = invariantRegistry.loadFromFile(invariantsFile);
-        if (loadSuccess) {
-          console.log(chalk.green(`✅ Loaded invariants from: ${invariantsFile}`));
+        // We'll load the separate file to supplement the context file invariants
+        const fileLoadSuccess = invariantRegistry.loadFromFile(invariantsFile);
+        if (fileLoadSuccess) {
+          console.log(chalk.green(`✅ Loaded project-specific invariants from: ${invariantsFile}`));
+          loadSuccess = true;
         } else {
-          console.log(chalk.yellow(`⚠️  Failed to load invariants from: ${invariantsFile}`));
-          console.log(chalk.yellow('Using default invariants...'));
+          console.log(chalk.yellow(`⚠️  Failed to load project-specific invariants from: ${invariantsFile}`));
         }
       } else {
-        console.log(chalk.yellow(`⚠️  Invariants file not found: ${invariantsFile}`));
-        console.log(chalk.yellow('Using default invariants...'));
+        console.log(chalk.yellow(`⚠️  No project-specific invariants file found: ${invariantsFile}`));
       }
 
       // If invariants couldn't be loaded or file doesn't exist, use defaults
@@ -808,6 +835,9 @@ program
   .option('--export <format>', 'Export ledger (json|csv)')
   .action(async (options) => {
     try {
+      // Initialize Authority Ledger with default path
+      const authorityLedger = new AuthorityLedger(path.join(process.cwd(), 'arcvision_context', 'architecture.authority.ledger.json'));
+      
       if (options.stats) {
         const stats = authorityLedger.getStats();
         console.log(chalk.blue('📊 Authority Ledger Statistics'));
@@ -845,7 +875,7 @@ program
       }
 
       // Default: show ledger info
-      console.log(chalk.blue('Authority Ledger Location: ./architecture.authority.ledger.json'));
+      console.log(chalk.blue('Authority Ledger Location: ./arcvision_context/architecture.authority.ledger.json'));
       console.log(chalk.yellow('Use --stats, --recent-blocks, or --export for detailed information'));
       process.exit(0);