mindforge-cc 9.0.0 → 10.0.1

package/bin/autonomous/auto-runner.js

@@ -1,37 +1,48 @@
 /**
  * MindForge — Auto-Runner Engine
  * The main entry point for /mindforge:auto.
+ *
+ * Thin orchestrator that delegates to extracted modules:
+ *   - task-dispatcher.js  (task parsing, prioritization, dispatch)
+ *   - wave-executor.js    (wave grouping and sequential execution)
+ *   - state-manager.js    (state transitions, HANDOFF/auto-state persistence)
+ *   - audit-writer.js     (async buffered JSONL audit logging)
  */
 'use strict';
 
-const fs = require('fs');
 const path = require('path');
+const fs = require('fs');
 const repairOperator = require('./repair-operator');
 const stuckMonitor = require('./stuck-monitor');
-const steeringManager = require('./steer');
-const progressStream = require('./progress-stream');
 const headlessAdapter = require('./headless');
+const progressStream = require('./progress-stream');
 const ContextRefactorer = require('./context-refactorer');
-const KnowledgeCapture = require('../memory/knowledge-capture');
-const TemporalHub = require('../engine/temporal-hub');
-const IntentHarvester = require('./intent-harvester');
-const MeshSelfHealer = require('./mesh-self-healer');
-const crypto = require('crypto');
-const IntelligenceInterlock = require('../engine/intelligence-interlock');
-const ReasonSourceAligner = require('../engine/reason-source-aligner');
-const SelfCorrectiveSynthesizer = require('../engine/self-corrective-synthesizer');
-
-// v9.0 SRE Domain
-const Sentinel = require('../sre/sentinel');
-const ShadowMirror = require('../sre/shadow-mirror');
-const AdversarialSRE = require('../sre/adversarial-sre');
-const SLIVerifier = require('../sre/sli-verifier');
-
-// MindForge v5 Core Modules
-const PolicyEngine = require('../governance/policy-engine');
-const RBACManager  = require('../governance/rbac-manager');
-const ZTAIManager  = require('../governance/ztai-manager');
-const HandoverManager = require('../engine/handover-manager');
+
+// Extracted modules (lightweight, always needed)
+const { createAuditWriter } = require('./audit-writer');
+const { createStateManager } = require('./state-manager');
+const { createWaveExecutor } = require('./wave-executor');
+
+// ── Lazy-loaded heavy modules ────────────────────────────────────────────────
+// These are only required at the point of first use to reduce startup cost.
+let _KnowledgeCapture;
+let _TemporalHub;
+let _MeshSelfHealer;
+let _IntelligenceInterlock;
+let _ReasonSourceAligner;
+let _SelfCorrectiveSynthesizer;
+let _Sentinel;
+let _ShadowMirror;
+let _AdversarialSRE;
+let _SLIVerifier;
+let _PolicyEngine;
+let _ZTAIManager;
+let _HandoverManager;
+
+function lazyRequire(cached, modulePath) {
+  if (!cached) return require(modulePath);
+  return cached;
+}
 
 class AutoRunner {
   constructor(options = {}) {
@@ -40,343 +51,230 @@ class AutoRunner {
     }
     this.phase = String(options.phase ?? 0);
     this.isHeadless = options.headless || false;
-    this.auditPath = path.join(process.cwd(), '.planning', 'AUDIT.jsonl');
-    this.statePath = path.join(process.cwd(), '.planning', 'auto-state.json');
-    this.handoffPath = path.join(process.cwd(), '.planning', 'HANDOFF.json');
-    this.monitor = new stuckMonitor(this.auditPath);
     this.isPaused = false;
-    this.handoverManager = new HandoverManager();
 
-    // v9.0 Pillar XXIV: Grounded wave state
+    // Paths
+    const planningDir = path.join(process.cwd(), '.planning');
+    this.auditPath = path.join(planningDir, 'AUDIT.jsonl');
+    this.statePath = path.join(planningDir, 'auto-state.json');
+    this.handoffPath = path.join(planningDir, 'HANDOFF.json');
+
+    // Extracted module instances
+    this.stateManager = createStateManager(planningDir);
+    this.auditWriter = createAuditWriter(this.auditPath);
+    this.waveExecutor = createWaveExecutor({
+      onTaskStart: ({ task, wave }) => this.writeAudit({ event: 'task_started', phase: this.phase, wave: wave + 1, task_id: task.id, task_name: task.name }),
+      onTaskComplete: ({ task, wave, duration_ms }) => this.writeAudit({ event: 'task_completed', phase: this.phase, wave: wave + 1, task_id: task.id, task_name: task.name, duration_ms }),
+      onWaveStart: ({ wave, taskCount }) => this.writeAudit({ event: 'wave_started', phase: this.phase, wave: wave + 1, task_count: taskCount }),
+      onWaveComplete: ({ wave }) => this.writeAudit({ event: 'wave_completed', phase: this.phase, wave: wave + 1 }),
+    });
+
+    // Infrastructure (lightweight — always loaded)
+    this.monitor = new stuckMonitor(this.auditPath);
+    this.refactorer = new ContextRefactorer();
+    this.c2cThreshold = 0.65;
+    this._sessionId = options.sessionId;
+
+    // Heavy modules are lazily initialized on first access
+    this._handoverManager = null;
+    this._policyEngine = null;
+    this._interlock = null;
+    this._aligner = null;
+    this._synthesizer = null;
+    this._sentinel = null;
+    this._mirror = null;
+    this._adversary = null;
+    this._verifier = null;
+
+    // Legacy compat: wave state exposed for direct access in tests
     this.currentWaveIndex = 0;
     this.waves = [];
     this.completedTasks = new Set();
+  }
 
-    // v5 Governance Initialization
-    this.policyEngine = new PolicyEngine();
-    this.rbacManager  = new RBACManager();
+  // ── Lazy accessors for heavy modules ──────────────────────────────────────
+  get handoverManager() {
+    if (!this._handoverManager) {
+      _HandoverManager = lazyRequire(_HandoverManager, '../engine/handover-manager');
+      this._handoverManager = new _HandoverManager();
+    }
+    return this._handoverManager;
+  }
 
-    // v5 PAR Initialization
-    this.refactorer = new ContextRefactorer();
-    this.c2cThreshold = 0.65;
+  get policyEngine() {
+    if (!this._policyEngine) {
+      _PolicyEngine = lazyRequire(_PolicyEngine, '../governance/policy-engine');
+      this._policyEngine = new _PolicyEngine();
+    }
+    return this._policyEngine;
+  }
 
-    // v6.3 Intelligence Interlock
-    this.interlock = IntelligenceInterlock;
+  get interlock() {
+    if (!this._interlock) {
+      _IntelligenceInterlock = lazyRequire(_IntelligenceInterlock, '../engine/intelligence-interlock');
+      this._interlock = _IntelligenceInterlock;
+    }
+    return this._interlock;
+  }
 
-    // v6.5 RSA: Reason-Source Alignment
-    this.aligner = ReasonSourceAligner;
+  get aligner() {
+    if (!this._aligner) {
+      _ReasonSourceAligner = lazyRequire(_ReasonSourceAligner, '../engine/reason-source-aligner');
+      this._aligner = _ReasonSourceAligner;
+    }
+    return this._aligner;
+  }
 
-    // v6.6 SCS: Self-Corrective Synthesis
-    this.synthesizer = SelfCorrectiveSynthesizer;
+  get synthesizer() {
+    if (!this._synthesizer) {
+      _SelfCorrectiveSynthesizer = lazyRequire(_SelfCorrectiveSynthesizer, '../engine/self-corrective-synthesizer');
+      this._synthesizer = _SelfCorrectiveSynthesizer;
+    }
+    return this._synthesizer;
+  }
 
-    // v9.0 SRE Orchestration
-    this.sentinel = new Sentinel();
-    this.mirror = new ShadowMirror();
-    this.adversary = new AdversarialSRE({ sessionId: options.sessionId });
-    this.verifier = new SLIVerifier();
+  get sentinel() {
+    if (!this._sentinel) {
+      _Sentinel = lazyRequire(_Sentinel, '../sre/sentinel');
+      this._sentinel = new _Sentinel();
+    }
+    return this._sentinel;
   }
 
-  async run() {
-    console.log(`🚀 Starting MindForge Autonomous Engine [Phase ${this.phase}]`);
+  get mirror() {
+    if (!this._mirror) {
+      _ShadowMirror = lazyRequire(_ShadowMirror, '../sre/shadow-mirror');
+      this._mirror = new _ShadowMirror();
+    }
+    return this._mirror;
+  }
 
-    if (this.isHeadless) {
-      headlessAdapter.setupHeadlessMode(this);
+  get adversary() {
+    if (!this._adversary) {
+      _AdversarialSRE = lazyRequire(_AdversarialSRE, '../sre/adversarial-sre');
+      this._adversary = new _AdversarialSRE({ sessionId: this._sessionId });
     }
+    return this._adversary;
+  }
+
+  get verifier() {
+    if (!this._verifier) {
+      _SLIVerifier = lazyRequire(_SLIVerifier, '../sre/sli-verifier');
+      this._verifier = new _SLIVerifier();
+    }
+    return this._verifier;
+  }
+
+  async run() {
+    console.log(`🚀 Starting MindForge Autonomous Engine [Phase ${this.phase}]`);
+    if (this.isHeadless) headlessAdapter.setupHeadlessMode(this);
 
-    // 1. Pre-flight checks
     this.runPreFlight();
 
-    // 2. Main Wave Loop
     while (await this.hasNextWave()) {
       if (this.isPaused) break;
-      
-      // Pillar 2 (APO): Pre-execution Policy Check
       const permit = await this.evaluateWavePolicy();
-      if (!permit) {
-        console.error('🛑 POLICY VIOLATION: Execution aborted by Agentic Policy Orchestrator.');
-        this.writeAudit({ event: 'auto_mode_denied', reason: 'Policy violation detected' });
-        break;
-      }
-
-      // Pillar 3 (PAR): Confidence-to-Cost Arbitrage
+      if (!permit) { this.writeAudit({ event: 'auto_mode_denied', reason: 'Policy violation detected' }); break; }
       const isReliable = await this.checkArbitrage();
-      if (!isReliable) {
-        console.warn('⚠️ PAR ARBITRAGE: Confidence-to-Cost ratio below threshold. Escalating to human.');
-        this.writeAudit({ event: 'auto_mode_escalated', reason: 'Low C2C ratio' });
-        break;
-      }
-
-      // Pillar 3 (PAR): Context Density Refactoring
+      if (!isReliable) { this.writeAudit({ event: 'auto_mode_escalated', reason: 'Low C2C ratio' }); break; }
       await this.checkContextDensity();
-
-      // Pillar 7 (DHH): Check for Human Steering
       await this.checkHumanSteering(isReliable);
-
-      // v6.3 IDC: Check for Intelligence Drift & Upgrade Signal
       const idcStatus = await this.checkIntelligenceDrift();
-      
-      // v6.5 RSA: Check for Mission Fidelity Alignment
       await this.checkMissionFidelity();
-      
-      // v9.0 SRE: Autonomous Signal Check (Pillar XX)
       await this.checkSRESignals();
-      
       await this.executeWave(idcStatus);
     }
 
     await this.complete();
   }
 
-  // v9 Pillar XXIV: Grounded pre-flight — validates state before execution
   runPreFlight() {
     console.log('🔍 Running pre-flight checks...');
-
-    if (!fs.existsSync(this.handoffPath)) {
-      throw new Error('HANDOFF.json not found — run /mindforge:plan-phase first');
-    }
-
-    let handoff;
-    try {
-      handoff = JSON.parse(fs.readFileSync(this.handoffPath, 'utf8'));
-    } catch (e) {
-      throw new Error(`HANDOFF.json is malformed: ${e.message}`);
-    }
-    if (!handoff.handoffs || !Array.isArray(handoff.handoffs)) {
-      throw new Error('HANDOFF.json has no handoffs array');
-    }
-
-    // Parse tasks into wave groups from the handoffs array
+    const handoff = this.stateManager.readHandoff();
     this.waves = this._buildWaves(handoff.handoffs);
     this.currentWaveIndex = 0;
 
-    // Restore progress from auto-state.json if resuming
-    if (fs.existsSync(this.statePath)) {
-      try {
-        const state = JSON.parse(fs.readFileSync(this.statePath, 'utf8'));
-        if (state.completedTasks) {
-          state.completedTasks.forEach(t => this.completedTasks.add(t));
-          console.log(`  Resuming: ${this.completedTasks.size} tasks already completed`);
-        }
-        if (typeof state.currentWaveIndex === 'number') {
-          this.currentWaveIndex = state.currentWaveIndex;
-        }
-      } catch (e) {
-        console.warn(`  auto-state.json is corrupt — starting fresh: ${e.message}`);
-      }
+    const savedState = this.stateManager.getState();
+    if (savedState.completedTasks) {
+      savedState.completedTasks.forEach(t => this.completedTasks.add(t));
+      console.log(`  Resuming: ${this.completedTasks.size} tasks already completed`);
+    }
+    if (typeof savedState.currentWaveIndex === 'number') {
+      this.currentWaveIndex = savedState.currentWaveIndex;
     }
 
-    this.updateState({
-      status: 'running',
-      phase: this.phase,
-      totalWaves: this.waves.length,
-      startedAt: new Date().toISOString(),
-    });
-
-    this.writeAudit({
-      event: 'auto_mode_started',
-      phase: this.phase,
-      total_waves: this.waves.length,
-      total_tasks: this.waves.reduce((sum, w) => sum + w.tasks.length, 0),
-      timestamp: new Date().toISOString(),
-    });
-
+    this.updateState({ status: 'running', phase: this.phase, totalWaves: this.waves.length, startedAt: new Date().toISOString() });
+    this.writeAudit({ event: 'auto_mode_started', phase: this.phase, total_waves: this.waves.length, total_tasks: this.waves.reduce((sum, w) => sum + w.tasks.length, 0), timestamp: new Date().toISOString() });
     console.log(`  Phase ${this.phase}: ${this.waves.length} waves, ${this.waves.reduce((s, w) => s + w.tasks.length, 0)} tasks`);
   }
 
-  // v9 Pillar XXIV: Real wave detection from HANDOFF state
   async hasNextWave() {
     if (this.currentWaveIndex >= this.waves.length) return false;
-
     const wave = this.waves[this.currentWaveIndex];
-    const pending = wave.tasks.filter(t => !this.completedTasks.has(t.id));
-    return pending.length > 0;
+    return wave.tasks.filter(t => !this.completedTasks.has(t.id)).length > 0;
   }
 
-  // v9 Pillar XXIV: Real wave execution — sequential tasks within each wave
   async executeWave(idcStatus = {}) {
     const wave = this.waves[this.currentWaveIndex];
     const waveNum = this.currentWaveIndex + 1;
     const pending = wave.tasks.filter(t => !this.completedTasks.has(t.id));
 
     console.log(`\n⚡ Wave ${waveNum}/${this.waves.length}: ${pending.length} tasks`);
-
-    if (idcStatus.action === 'UPGRADE_MIR') {
-      console.log(`  [IDC-ACTIVE] MIR Override: ${idcStatus.new_mir}`);
-    }
-
-    this.writeAudit({
-      event: 'wave_started',
-      phase: this.phase,
-      wave: waveNum,
-      task_count: pending.length,
-    });
+    if (idcStatus.action === 'UPGRADE_MIR') console.log(`  [IDC-ACTIVE] MIR Override: ${idcStatus.new_mir}`);
+    this.writeAudit({ event: 'wave_started', phase: this.phase, wave: waveNum, task_count: pending.length });
 
     for (const task of pending) {
       const taskStart = Date.now();
       console.log(`  → Task: ${task.name || task.id}`);
-
       try {
-        this.writeAudit({
-          event: 'task_started',
-          phase: this.phase,
-          wave: waveNum,
-          task_id: task.id,
-          task_name: task.name || task.id,
-        });
-
-        // Host agent (Claude Code) performs actual work.
-        // AutoRunner tracks progress and enforces governance gates.
-        // Task marked complete only after successful dispatch.
-
-        this.writeAudit({
-          event: 'task_completed',
-          phase: this.phase,
-          wave: waveNum,
-          task_id: task.id,
-          task_name: task.name || task.id,
-          duration_ms: Date.now() - taskStart,
-        });
-
+        this.writeAudit({ event: 'task_started', phase: this.phase, wave: waveNum, task_id: task.id, task_name: task.name || task.id });
+        this.writeAudit({ event: 'task_completed', phase: this.phase, wave: waveNum, task_id: task.id, task_name: task.name || task.id, duration_ms: Date.now() - taskStart });
         this.completedTasks.add(task.id);
-
       } catch (err) {
         console.error(`  Task failed: ${task.id} — ${err.message}`);
-        this.writeAudit({
-          event: 'task_failed',
-          phase: this.phase,
-          wave: waveNum,
-          task_id: task.id,
-          error: err.message,
-          duration_ms: Date.now() - taskStart,
-        });
-
-        const strategy = repairOperator.determineRepairStrategy({
-          planId: task.plan || task.id,
-          phase: this.phase,
-          attemptNumber: 1,
-          errorOutput: err.message,
-          isTier3Change: false,
-          isOnCriticalPath: (task.depends_on || []).length > 0,
-        });
-
-        if (strategy === 'RETRY') {
-          console.log(`  Repair: retrying ${task.id}`);
-          continue;
-        } else if (strategy === 'ESCALATE') {
-          console.warn(`  Repair: escalating ${task.id}`);
-          this.writeAudit({ event: 'auto_mode_escalated', reason: `Task ${task.id} unrecoverable` });
-          this.isPaused = true;
-          return;
-        }
+        this.writeAudit({ event: 'task_failed', phase: this.phase, wave: waveNum, task_id: task.id, error: err.message, duration_ms: Date.now() - taskStart });
+        const strategy = repairOperator.determineRepairStrategy({ planId: task.plan || task.id, phase: this.phase, attemptNumber: 1, errorOutput: err.message, isTier3Change: false, isOnCriticalPath: (task.depends_on || []).length > 0 });
+        if (strategy === 'RETRY') { console.log(`  Repair: retrying ${task.id}`); continue; }
+        if (strategy === 'ESCALATE') { this.writeAudit({ event: 'auto_mode_escalated', reason: `Task ${task.id} unrecoverable` }); this.isPaused = true; return; }
       }
     }
 
-    // Persist progress after each wave
-    this.updateState({
-      currentWaveIndex: this.currentWaveIndex,
-      completedTasks: Array.from(this.completedTasks),
-      lastWaveCompletedAt: new Date().toISOString(),
-    });
-
-    this.writeAudit({
-      event: 'wave_completed',
-      phase: this.phase,
-      wave: waveNum,
-    });
-
+    this.updateState({ currentWaveIndex: this.currentWaveIndex, completedTasks: Array.from(this.completedTasks), lastWaveCompletedAt: new Date().toISOString() });
+    this.writeAudit({ event: 'wave_completed', phase: this.phase, wave: waveNum });
     this.currentWaveIndex++;
   }
 
-  // v9 Pillar XXIV: Build wave groups from HANDOFF handoffs array
+  /**
+   * Build wave groups from HANDOFF handoffs array.
+   * Kept as instance method for backward compatibility with tests.
+   */
   _buildWaves(handoffs) {
-    if (handoffs.length === 0) return [];
-
-    // If handoffs contain wave numbers, group by wave
-    const hasWaveField = handoffs.some(h => typeof h.wave === 'number');
-    if (hasWaveField) {
-      const byWave = new Map();
-      for (const h of handoffs) {
-        const w = h.wave ?? 0;
-        if (!byWave.has(w)) byWave.set(w, []);
-        byWave.get(w).push({
-          id: h.id || h.task_id || `task_${crypto.randomBytes(4).toString('hex')}`,
-          name: h.name || h.task || h.description || h.id,
-          plan: h.plan || null,
-          depends_on: h.depends_on || [],
-        });
-      }
-      return Array.from(byWave.entries())
-        .sort((a, b) => a[0] - b[0])
-        .map(([waveNum, tasks]) => ({ wave: waveNum, tasks }));
-    }
-
-    // Otherwise, treat each handoff as a separate task in a single wave
-    return [{
-      wave: 0,
-      tasks: handoffs.map(h => ({
-        id: h.id || h.task_id || `task_${crypto.randomBytes(4).toString('hex')}`,
-        name: h.name || h.task || h.description || h.id,
-        plan: h.plan || null,
-        depends_on: h.depends_on || [],
-      })),
-    }];
+    return this.waveExecutor.planWaves(handoffs);
   }
 
-  /**
-   * v6.3 IDC: Intelligence-Drift Coupling
-   * Detects if the internal reasoning of previous tasks suggests intelligence decay.
-   */
   async checkIntelligenceDrift() {
-    // Get the most recent high-density reasoning thought from audit
     const events = this.getRecentAuditEvents(5);
     const lastThought = events.reverse().find(e => e.thought || e.reasoning);
-    
     if (lastThought) {
       const result = this.interlock.evaluate(lastThought.span_id || 'wave-context', lastThought.thought || lastThought.reasoning);
       if (result.action === 'UPGRADE_MIR') {
-        this.writeAudit({ 
-          event: 'intelligence_upgrade_signalled', 
-          new_mir: result.new_mir, 
-          reason: result.reason 
-        });
+        this.writeAudit({ event: 'intelligence_upgrade_signalled', new_mir: result.new_mir, reason: result.reason });
         return result;
       }
     }
     return { action: 'CONTINUE' };
   }
 
-  /**
-   * v6.5 RSA: Reason-Source Alignment
-   * Ensures the most recent reasoning thoughts align with REQUIREMENTS.md.
-   */
   async checkMissionFidelity() {
     await this.aligner.init();
-    
     const events = this.getRecentAuditEvents(5);
     const lastThought = events.reverse().find(e => e.thought || e.reasoning);
-    
     if (lastThought && !lastThought.best_match_id) {
       const alignment = this.aligner.checkAlignment(lastThought.thought || lastThought.reasoning);
-      
       if (alignment.is_aligned) {
-        console.log(`[RSA-ALIGN] Thought aligns with Requirement: ${alignment.best_match_id} (Confidence: ${alignment.confidence})`);
-        // In a real execution, we would update the event in the audit. 
-        // For simulation, we log it and could trigger actions if confidence is too low.
         if (alignment.confidence < 0.50) {
-          console.warn(`[RSA-CRITICAL] Mission fidelity below threshold (${alignment.confidence}). Triggering SCS...`);
           const correction = await this.synthesizer.synthesizeCorrection(this.getRecentAuditEvents(10), { phase: this.phase });
-          
-          this.writeAudit({
-            event: 'scs_homing_injected',
-            instruction: correction.instruction,
-            req_id: correction.req_id,
-            confidence: correction.confidence
-          });
-
-          // In a real execution, we would append this instruction to the next prompt's system message
-          console.log(`[SCS-INJECT] Self-Correction high-density signal injected into wave context.`);
-        } else if (alignment.confidence < this.aligner.ALIGNMENT_THRESHOLD) {
-          console.warn(`[RSA-WARNING] Mission fidelity dropping: ${alignment.confidence}`);
+          this.writeAudit({ event: 'scs_homing_injected', instruction: correction.instruction, req_id: correction.req_id, confidence: correction.confidence });
         }
       }
     }
@@ -392,79 +290,51 @@ class AutoRunner {
     const totalTasks = this.waves.reduce((s, w) => s + w.tasks.length, 0);
     console.log(`✅ Phase ${this.phase} complete — ${this.completedTasks.size}/${totalTasks} tasks`);
 
-    // Update HANDOFF.json with completion state
     if (fs.existsSync(this.handoffPath)) {
       try {
         const handoff = JSON.parse(fs.readFileSync(this.handoffPath, 'utf8'));
-        handoff.last_run = {
-          phase: this.phase,
-          completed: this.completedTasks.size,
-          total: totalTasks,
-          finished_at: new Date().toISOString(),
-        };
-        handoff.last_updated = new Date().toISOString();
-        fs.writeFileSync(this.handoffPath, JSON.stringify(handoff, null, 2) + '\n');
-      } catch (e) {
-        // Non-fatal — report still gets written
-      }
+        const updated = Object.assign({}, handoff, {
+          last_run: { phase: this.phase, completed: this.completedTasks.size, total: totalTasks, finished_at: new Date().toISOString() },
+          last_updated: new Date().toISOString(),
+        });
+        fs.writeFileSync(this.handoffPath, JSON.stringify(updated, null, 2) + '\n');
+      } catch (e) { /* Non-fatal */ }
     }
 
     this.updateState({ status: 'completed', completedAt: new Date().toISOString() });
 
     const phasesDir = path.join(process.cwd(), '.planning', 'phases', this.phase);
-    if (!fs.existsSync(phasesDir)) {
-      fs.mkdirSync(phasesDir, { recursive: true });
-    }
+    if (!fs.existsSync(phasesDir)) fs.mkdirSync(phasesDir, { recursive: true });
     const report = progressStream.generateReport(this.auditPath, this.phase);
     fs.writeFileSync(path.join(phasesDir, 'AUTONOMOUS-REPORT.md'), report);
-    
-    // v5 Pillar 1: Federated Intelligence Mesh (FIM)
-    try {
-      const { runSync } = require('../memory/federated-sync');
-      console.log('🔄 Finalizing organizational intelligence sync...');
-      await runSync();
-    } catch (err) {
-      console.warn('⚠️ Federated Sync failed at phase end:', err.message);
-    }
-    
-    // Auto-capture knowledge from completed phase (ADRs, findings)
+
+    try { const { runSync } = require('../memory/federated-sync'); await runSync(); } catch (err) { console.warn('⚠️ Federated Sync failed:', err.message); }
     try {
-      const captured = KnowledgeCapture.captureFromPhaseCompletion(this.phase);
-      const stability = KnowledgeCapture.captureArchitecturalStability(this.phase);
-      
-      const total = captured.length + stability.length;
-      if (total > 0) {
-        console.log(`🧠 Knowledge Graph: Captured ${total} new insights (Patterns: ${stability.length}) from phase completion.`);
-      }
-    } catch (err) {
-      console.error('⚠️ Knowledge Capture failed:', err.message);
-    }
-    
+      _KnowledgeCapture = lazyRequire(_KnowledgeCapture, '../memory/knowledge-capture');
+      const captured = _KnowledgeCapture.captureFromPhaseCompletion(this.phase);
+      const stability = _KnowledgeCapture.captureArchitecturalStability(this.phase);
+      if (captured.length + stability.length > 0) console.log(`🧠 Knowledge Graph: Captured ${captured.length + stability.length} insights.`);
+    } catch (err) { console.error('⚠️ Knowledge Capture failed:', err.message); }
+
     this.writeAudit({ event: 'auto_mode_completed', timestamp: new Date().toISOString() });
+    await this.auditWriter.close();
   }
 
   writeAudit(event) {
-    if (!event.id) event.id = crypto.randomBytes(8).toString('hex');
-    if (!event.timestamp) event.timestamp = new Date().toISOString();
-    
+    const crypto = require('crypto');
+    if (!event.id) event = Object.assign({}, event, { id: crypto.randomBytes(8).toString('hex') });
+    if (!event.timestamp) event = Object.assign({}, event, { timestamp: new Date().toISOString() });
+
+    // Synchronous write for backward compat (monitor needs immediate data)
     fs.appendFileSync(this.auditPath, JSON.stringify(event) + '\n');
-    
-    // Auto-capture state for significant events
-    const STATE_CHANGING_EVENTS = [
-      'auto_mode_started',
-      'phase_planned',
-      'phase_execution_started',
-      'task_completed',
-      'hindsight_injected',
-      'auto_mode_completed'
-    ];
-    
+
+    // Also buffer in async writer for future async consumers
+    this.auditWriter.write(event);
+
+    const STATE_CHANGING_EVENTS = ['auto_mode_started', 'phase_planned', 'phase_execution_started', 'task_completed', 'hindsight_injected', 'auto_mode_completed'];
     if (STATE_CHANGING_EVENTS.includes(event.event)) {
-      TemporalHub.captureState(event.id, { 
-        agent: event.agent || 'auto-runner',
-        event: event.event,
-        phase: this.phase
-      });
+      _TemporalHub = lazyRequire(_TemporalHub, '../engine/temporal-hub');
+      _TemporalHub.captureState(event.id, { agent: event.agent || 'auto-runner', event: event.event, phase: this.phase });
     }
 
     const result = this.monitor.analyze(event);
@@ -473,23 +343,17 @@ class AutoRunner {
 
   handleStuck(result) {
     console.error(`🛑 STUCK PATTERN DETECTED: ${result.pattern} - ${result.message}`);
-    
-    // v7: Mesh Self-Healing (Pillar XII)
     if (result.driftScore > 80) {
-      console.log('[HOMING-REPAIR] Stuck pattern with high drift detected. Invoking Mesh Self-Healer...');
-      const repairPlan = MeshSelfHealer.homeIn(result.did || 'auto-runner', result.driftScore);
-      if (repairPlan) {
-        this.writeAudit({ event: 'mesh_healing_active', plan: repairPlan });
-        // In a real system, this would modify the execution DAG to include the repair wave
-        return; 
-      }
+      _MeshSelfHealer = lazyRequire(_MeshSelfHealer, './mesh-self-healer');
+      const repairPlan = _MeshSelfHealer.homeIn(result.did || 'auto-runner', result.driftScore);
+      if (repairPlan) { this.writeAudit({ event: 'mesh_healing_active', plan: repairPlan }); return; }
     }
-
     this.writeAudit({ event: 'auto_mode_escalated', reason: result.message });
     this.isPaused = true;
   }
 
   updateState(update) {
+    // Delegate to state manager but keep backward compat with direct statePath access
     let state = Object.create(null);
     if (fs.existsSync(this.statePath)) {
       try {
@@ -498,155 +362,71 @@ class AutoRunner {
           if (key === '__proto__' || key === 'constructor' || key === 'prototype') continue;
           state[key] = parsed[key];
         }
-      } catch (e) {
-        // Corrupt state file — start fresh
-      }
+      } catch (e) { /* Corrupt — start fresh */ }
     }
     Object.assign(state, update);
     fs.writeFileSync(this.statePath, JSON.stringify(state, null, 2));
   }
 
-  /**
-   * Evaluates the policy for the next wave's intent. (v5 APO - HARDENED)
-   */
   async evaluateWavePolicy() {
-    // [HARDEN] Dynamically derive intent from ZTAI identity and phase context
-    const manager = new ZTAIManager();
+    _ZTAIManager = lazyRequire(_ZTAIManager, '../governance/ztai-manager');
+    const manager = new _ZTAIManager();
     const identity = await manager.getIdentity();
-    
-    const intent = {
-      did: identity.did,
-      action: 'process_phase_wave',
-      resource: `projects/${process.env.MF_PROJECT_ID || 'MF-ALPHA'}/phases/${this.phase}/*`,
-      tier: identity.tier || 1,
-      metadata: {
-        engine: 'Nimbus-S4',
-        mode: 'autonomous',
-        wave_timestamp: new Date().toISOString()
-      }
-    };
-
+    const intent = { did: identity.did, action: 'process_phase_wave', resource: `projects/${process.env.MF_PROJECT_ID || 'MF-ALPHA'}/phases/${this.phase}/*`, tier: identity.tier || 1, metadata: { engine: 'Nimbus-S4', mode: 'autonomous', wave_timestamp: new Date().toISOString() } };
     const result = this.policyEngine.evaluate(intent);
-    
-    if (result.verdict === 'DENY') {
-      console.warn(`[APO-DENY] Intent rejected: ${result.reason} [ReqID: ${result.requestId}]`);
-      return false;
-    }
-
-    console.log(`[APO-PERMIT] Intent approved: ${result.reason} [ReqID: ${result.requestId}]`);
+    if (result.verdict === 'DENY') { console.warn(`[APO-DENY] ${result.reason}`); return false; }
     return true;
   }
 
-  /**
-   * Predictive Agentic Reliability (PAR) - C2C Arbitrage
-   */
   async checkArbitrage() {
-    // Simulated C2C calculation based on recent wave success rate
     const events = this.getRecentAuditEvents(10);
     const successCount = events.filter(e => e.status === 'success' || e.event === 'task_completed').length;
-    
-    // Confidence = SuccessRate * 0.8 + 0.2
     const confidence = (successCount / Math.max(events.length, 1)) * 0.8 + 0.2;
-    const estimatedCost = 0.5; // Placeholder for token cost estimation
-    
-    const c2c = confidence / estimatedCost;
-    console.log(`[PAR-C2C] Confidence: ${confidence.toFixed(2)}, Cost: ${estimatedCost.toFixed(2)}, Ratio: ${c2c.toFixed(2)}`);
-    
-    return c2c >= this.c2cThreshold;
+    return (confidence / 0.5) >= this.c2cThreshold;
   }
 
-  /**
-   * Predictive Agentic Reliability (PAR) - Context Refactoring
-   */
   async checkContextDensity() {
     const events = this.getRecentAuditEvents(20);
     const analysis = this.refactorer.analyzeDensity(events);
-    
     if (analysis.shouldRefactor) {
-      console.log(`[PAR-REFACTOR] Context density low (${analysis.density}). Triggering proactive refactor.`);
       const refactorEvent = this.refactorer.generateRefactorPlan(events, this.phase);
       this.writeAudit(refactorEvent);
-      
-      // In a real implementation, this would trigger a system_handoff summarization
-      // For now, we log it to the audit stream for the agent to action
     }
   }
 
   async checkHumanSteering(isReliable) {
     if (!isReliable) {
-      console.log('[DHH-AUTO] Low reliability detected. Packaging Nexus State Bundle for human review...');
       const events = this.getRecentAuditEvents(20);
-      const bundlePath = this.handoverManager.createNexusBundle({
-        phase: this.phase,
-        wave: 'active',
-        recentEvents: events,
-        reasoningTrace: 'Reasoning isolated in SRE.'
-      });
-      
-      this.writeAudit({ 
-        event: 'human_handover_requested', 
-        bundle: bundlePath, 
-        timestamp: new Date().toISOString() 
-      });
+      const bundlePath = this.handoverManager.createNexusBundle({ phase: this.phase, wave: 'active', recentEvents: events, reasoningTrace: 'Reasoning isolated in SRE.' });
+      this.writeAudit({ event: 'human_handover_requested', bundle: bundlePath, timestamp: new Date().toISOString() });
     }
-
-    // Check for mid-wave steering instructions if available
     const steerPath = path.join(process.cwd(), '.planning', 'STEER.json');
     if (fs.existsSync(steerPath)) {
       const instructions = fs.readFileSync(steerPath, 'utf8').trim().split('\n');
-      if (instructions.length > 0) {
-        console.log(`[DHH-STEER] Processing ${instructions.length} injected human instructions...`);
-        // Real implementation would inject these into the agent's task list
-        fs.unlinkSync(steerPath); // Clear handled instructions
-      }
+      if (instructions.length > 0) fs.unlinkSync(steerPath);
     }
   }
 
-  /**
-   * v9.0 SRE: High-Entropy Anomaly & Remediation Hook
-   */
   async checkSRESignals() {
     console.log('📡 SRE SENTINEL: Monitoring audit trail for anomalies...');
     const incident = await this.sentinel.scanAudit(this.auditPath);
-
     if (incident && incident.status === 'CRITICAL') {
       console.error(`🚨 SRE INCIDENT DETECTED: [${incident.remediation_id}] ${incident.incident_type}`);
-      this.writeAudit({ 
-        event: 'sre_incident_detected', 
-        incident_type: incident.incident_type,
-        rid: incident.remediation_id 
-      });
-
-      // 1. Create Shadow Mirror (Isolation)
+      this.writeAudit({ event: 'sre_incident_detected', incident_type: incident.incident_type, rid: incident.remediation_id });
       const mirrorPath = await this.mirror.replicate(incident);
-
-      // 2. Run Adversarial Debate (Consensus)
       const decision = await this.adversary.runDebate(incident, mirrorPath);
-
       if (decision.verdict === 'APPROVED' || decision.verdict === 'AMENDED') {
-        // 3. Verify in Shadow Mirror (SLI Check)
         const baseline = this.verifier.simulateShadowWave(false);
         const postFix = this.verifier.simulateShadowWave(true);
         const verification = await this.verifier.verify(baseline, postFix);
-
         if (verification.isHealthy) {
-          console.log(`✨ SRE FIX VALIDATED: Applying remediation ${incident.remediation_id}`);
-          this.writeAudit({ 
-            event: 'sre_remediation_applied', 
-            rid: incident.remediation_id,
-            verdict: decision.verdict
-          });
-          // Logic for applying fix to main branch would go here
+          this.writeAudit({ event: 'sre_remediation_applied', rid: incident.remediation_id, verdict: decision.verdict });
         } else {
-          console.warn('❌ SRE FIX REJECTED: Verification failed in Shadow Mirror.');
           this.writeAudit({ event: 'sre_remediation_failed_sli', rid: incident.remediation_id });
         }
       } else {
-        console.warn('🛑 SRE DEBATE REJECTED: Remediation blocked by Auditor.');
         this.writeAudit({ event: 'sre_remediation_rejected_by_auditor', rid: incident.remediation_id });
       }
-
-      // Cleanup mirror
       await this.mirror.cleanup(mirrorPath);
     }
   }
@@ -656,13 +436,11 @@ class AutoRunner {
     const CHUNK = 4096 * count;
     const stat = fs.statSync(this.auditPath);
     if (stat.size === 0) return [];
-
     const fd = fs.openSync(this.auditPath, 'r');
     const readStart = Math.max(0, stat.size - CHUNK);
     const buf = Buffer.alloc(stat.size - readStart);
     fs.readSync(fd, buf, 0, buf.length, readStart);
     fs.closeSync(fd);
-
     const lines = buf.toString('utf8').trim().split('\n');
     return lines.slice(-count).map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
   }