mindforge-cc 8.2.0 → 9.0.0

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/autonomous/auto-runner.js

@@ -1,378 +0,0 @@
-/**
- * MindForge — Auto-Runner Engine
- * The main entry point for /mindforge:auto.
- */
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const repairOperator = require('./repair-operator');
-const stuckMonitor = require('./stuck-monitor');
-const steeringManager = require('./steer');
-const progressStream = require('./progress-stream');
-const headlessAdapter = require('./headless');
-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');
-
-// 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');
-
-class AutoRunner {
-  constructor(options = {}) {
-    this.phase = options.phase;
-    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.monitor = new stuckMonitor(this.auditPath);
-    this.isPaused = false;
-    this.handoverManager = new HandoverManager();
-
-    // v5 Governance Initialization
-    this.policyEngine = new PolicyEngine();
-    this.rbacManager  = new RBACManager();
-
-    // v5 PAR Initialization
-    this.refactorer = new ContextRefactorer();
-    this.c2cThreshold = 0.65;
-
-    // v6.3 Intelligence Interlock
-    this.interlock = IntelligenceInterlock;
-
-    // v6.5 RSA: Reason-Source Alignment
-    this.aligner = ReasonSourceAligner;
-
-    // v6.6 SCS: Self-Corrective Synthesis
-    this.synthesizer = SelfCorrectiveSynthesizer;
-  }
-
-  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
-      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
-      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();
-      
-      await this.executeWave(idcStatus);
-    }
-
-    await this.complete();
-  }
-
-  runPreFlight() {
-    console.log('🔍 Running pre-flight checks...');
-    // Real logic would check git status, health, etc.
-    this.writeAudit({ event: 'auto_mode_started', phase: this.phase, timestamp: new Date().toISOString() });
-  }
-
-  async hasNextWave() {
-    // Logic to check HANDOFF.json for incomplete waves
-    return false; // Placeholder for now
-  }
-
-  async executeWave(idcStatus = {}) {
-    // Parallel task execution logic...
-    if (idcStatus.action === 'UPGRADE_MIR') {
-      console.log(`[IDC-ACTIVE] Wave executing with MIR Override: ${idcStatus.new_mir}`);
-    }
-  }
-
-  /**
-   * 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 
-        });
-        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}`);
-        }
-      }
-    }
-  }
-
-  async pause() {
-    this.isPaused = true;
-    this.updateState({ status: 'paused' });
-    this.writeAudit({ event: 'auto_mode_paused', timestamp: new Date().toISOString() });
-  }
-
-  async complete() {
-    console.log('✅ Phase complete!');
-    const report = progressStream.generateReport(this.auditPath, this.phase);
-    fs.writeFileSync(path.join(process.cwd(), `.planning/phases/${this.phase}/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 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);
-    }
-    
-    this.writeAudit({ event: 'auto_mode_completed', timestamp: new Date().toISOString() });
-  }
-
-  writeAudit(event) {
-    if (!event.id) event.id = crypto.randomBytes(8).toString('hex');
-    if (!event.timestamp) event.timestamp = new Date().toISOString();
-    
-    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'
-    ];
-    
-    if (STATE_CHANGING_EVENTS.includes(event.event)) {
-      TemporalHub.captureState(event.id, { 
-        agent: event.agent || 'auto-runner',
-        event: event.event,
-        phase: this.phase
-      });
-    }
-
-    const result = this.monitor.analyze(event);
-    if (result) this.handleStuck(result);
-  }
-
-  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; 
-      }
-    }
-
-    this.writeAudit({ event: 'auto_mode_escalated', reason: result.message });
-    process.exit(10);
-  }
-
-  updateState(update) {
-    let state = {};
-    if (fs.existsSync(this.statePath)) {
-      state = JSON.parse(fs.readFileSync(this.statePath, 'utf8'));
-    }
-    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();
-    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 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}]`);
-    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;
-  }
-
-  /**
-   * 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() 
-      });
-    }
-
-    // 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
-      }
-    }
-  }
-
-  getRecentAuditEvents(count) {
-    if (!fs.existsSync(this.auditPath)) return [];
-    const lines = fs.readFileSync(this.auditPath, 'utf8').trim().split('\n');
-    return lines.slice(-count).map(l => JSON.parse(l));
-  }
-}
-
-module.exports = AutoRunner;

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/autonomous/context-refactorer.js

@@ -1,64 +0,0 @@
-/**
- * MindForge — Context Refactorer Engine (v5.0.0-PAR)
- * Monitors context density and triggers proactive summarization/refactoring.
- */
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-class ContextRefactorer {
-  constructor(options = {}) {
-    this.threshold = options.threshold || 0.3; // Min density before refactor
-    this.windowSize = options.windowSize || 20;
-    this.history = [];
-  }
-
-  /**
-   * Analyze the current context density.
-   * Density = (Implementation Events) / (Total Events)
-   */
-  analyzeDensity(events) {
-    this.history = events.slice(-this.windowSize);
-    
-    if (this.history.length < 5) return { density: 1.0, shouldRefactor: false };
-
-    const implementationEvents = this.history.filter(h => 
-      h.tool === 'run_command' || 
-      h.tool === 'replace_file_content' || 
-      h.tool === 'multi_replace_file_content' ||
-      h.event === 'task_completed'
-    );
-
-    const totalEvents = this.history.length;
-    const density = implementationEvents.length / totalEvents;
-
-    return {
-      density: parseFloat(density.toFixed(2)),
-      shouldRefactor: density < this.threshold
-    };
-  }
-
-  /**
-   * Generates a "Context Refactor" recommendation.
-   */
-  generateRefactorPlan(events, phase) {
-    const reasoningChain = events
-      .filter(e => e.event === 'reasoning_trace')
-      .map(e => `- ${e.thought}`)
-      .join('\n');
-
-    return {
-      event: 'context_refactor_triggered',
-      phase,
-      message: 'Context density low. Initiating proactive refactoring.',
-      action: 'SUMMARIZE_AND_RESET',
-      payload: {
-        summary_prompt: `The current reasoning chain has become dense (${this.threshold}). Summarize the progress for Phase ${phase} and reset the active context window.`,
-        trace_sample: reasoningChain.slice(-500) // Last few thoughts for context
-      }
-    };
-  }
-}
-
-module.exports = ContextRefactorer;

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/autonomous/headless.js

@@ -1,36 +0,0 @@
-/**
- * MindForge — Headless Adapter
- * Handles signal management and non-interactive output.
- */
-'use strict';
-
-function setupHeadlessMode(executor) {
-  // Disable fancy TTY reporting
-  process.env.NO_COLOR = '1';
-  process.env.INTERACTIVE = '0';
-
-  // Hardened signal handling to prevent race conditions during write
-  let isShuttingDown = false;
-
-  async function handleSignal(signal) {
-    if (isShuttingDown) return;
-    isShuttingDown = true;
-
-    console.error(`\n⚠️ Received ${signal}. Snapshotting state for resumption...`);
-
-    try {
-      // pause() ensures all state is flushed to disk and current step is stabilized
-      await executor.pause();
-      console.error('✅ State saved. You can resume with /mindforge:auto --resume');
-      process.exit(0);
-    } catch (err) {
-      console.error('❌ Failed to save state during shutdown:', err.message);
-      process.exit(1);
-    }
-  }
-
-  process.on('SIGTERM', () => handleSignal('SIGTERM'));
-  process.on('SIGINT', () => handleSignal('SIGINT'));
-}
-
-module.exports = { setupHeadlessMode };

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/autonomous/intent-harvester.js

@@ -1,80 +0,0 @@
-/**
- * MindForge v7 — Proactive Semantic Homing (Pillar XII)
- * Intent Harvester: Proactively scans and claims unassigned tasks.
- */
-'use strict';
-
-const fs = require('node:fs');
-const path = require('node:path');
-const crypto = require('node:crypto');
-
-class IntentHarvester {
-  constructor() {
-    this.planningDir = path.join(process.cwd(), '.planning');
-    this.backlogPath = path.join(this.planningDir, 'BACKLOG.json');
-    this.handoffPath = path.join(this.planningDir, 'HANDOFF.json');
-  }
-
-  /**
-   * Scans for unassigned intent in the backlog and peer handoffs.
-   */
-  async idleScan() {
-    console.log('[HOMING-SCAN] Agents transitioning to "Proactive Hunter" mode. Scanning FIM for unassigned intent...');
-    
-    const tasks = [];
-    if (fs.existsSync(this.backlogPath)) {
-      const backlog = JSON.parse(fs.readFileSync(this.backlogPath, 'utf8'));
-      tasks.push(...backlog.filter(t => t.status === 'unassigned' || t.status === 'pending'));
-    }
-
-    if (fs.existsSync(this.handoffPath)) {
-      const handoff = JSON.parse(fs.readFileSync(this.handoffPath, 'utf8'));
-      tasks.push(...(handoff.open_intents || []));
-    }
-
-    return tasks;
-  }
-
-  /**
-   * Autonomous task claiming based on agent Skill-Score.
-   */
-  async intentGrab(agent, tasks) {
-    if (tasks.length === 0) return null;
-
-    console.log(`[HOMING-GRAB] Agent ${agent.did} evaluating ${tasks.length} unassigned intents...`);
-    
-    // Sort tasks by Skill-Match affinity
-    const prioritized = tasks.map(task => ({
-      task,
-      score: this.calculateAffinity(agent, task)
-    })).sort((a, b) => b.score - a.score);
-
-    const bestMatch = prioritized[0];
-    if (bestMatch.score > 70) {
-      console.log(`[HOMING-GRAB] High affinity detected (${bestMatch.score}). Agent ${agent.did} claiming: ${bestMatch.task.description}`);
-      return this.claimTask(agent, bestMatch.task);
-    }
-
-    return null;
-  }
-
-  calculateAffinity(agent, task) {
-    // Simulated skill-affinity calculation
-    const skills = agent.skills || [];
-    const taskReqs = task.required_skills || [];
-    
-    const matchCount = taskReqs.filter(s => skills.includes(s)).length;
-    return (matchCount / Math.max(taskReqs.length, 1)) * 100;
-  }
-
-  async claimTask(agent, task) {
-    task.assigned_to = agent.did;
-    task.status = 'active';
-    task.claimedAt = new Date().toISOString();
-    
-    // Update local state (in a real system this would be a atomic mesh update)
-    return task;
-  }
-}
-
-module.exports = new IntentHarvester();

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/autonomous/mesh-self-healer.js

@@ -1,67 +0,0 @@
-/**
- * MindForge v7 — Proactive Semantic Homing (Pillar XII)
- * Mesh Self-Healer: Peer agents "home in" on drifting nodes to provide collaborative reasoning.
- */
-'use strict';
-
-const fs = require('node:fs');
-const path = require('node:path');
-
-class MeshSelfHealer {
-  constructor() {
-    this.auditPath = path.join(process.cwd(), '.planning', 'AUDIT.jsonl');
-  }
-
-  /**
-   * Peer agents "home in" on a node with high logic drift.
-   */
-  async homeIn(driftingAgentDid, driftScore) {
-    if (driftScore < 80) return null; // Only home in on major drift
-    
-    console.log(`[HOMING-HEAL] Global Mesh Alert: Agent ${driftingAgentDid} experiencing critical logic drift (${driftScore}). Peer agents redirecting...`);
-    
-    // Find nearby idle agents or specialists
-    const peers = this.findAvailablePeers(driftingAgentDid);
-    const healingNodes = [];
-
-    for (const peer of peers) {
-      console.log(`[HOMING-HEAL] Agent ${peer.did} homing in on ${driftingAgentDid} to provide collective reasoning support.`);
-      const supportTrace = await this.provideCollectiveReasoning(peer, driftingAgentDid);
-      healingNodes.push(supportTrace);
-    }
-
-    return this.reconcileReasoning(healingNodes);
-  }
-
-  findAvailablePeers(driftingAgentDid) {
-    // Simulated peer discovery
-    return [
-      { did: 'did:mindforge:peer-1-specialist', name: 'Refactor Specialist' },
-      { did: 'did:mindforge:peer-2-architect', name: 'Security Architect' }
-    ];
-  }
-
-  async provideCollectiveReasoning(peer, target) {
-    // Peer agent provides a second opinion/reasoning node
-    return {
-      provider: peer.did,
-      target: target,
-      reasoning: 'Recommended steering for drift recovery based on Mesh-State: Re-syncing with Sovereign-Reason-Enclave.',
-      confidence: 94
-    };
-  }
-
-  reconcileReasoning(nodes) {
-    // Merge peer reasoning nodes into a single corrective steering vector
-    const consensus = nodes[0].reasoning; // Mock consensus
-    console.log('[HOMING-HEAL] Collective reasoning consensus acheived: 100% agreement on recovery vector.');
-    
-    return {
-      type: 'collective_repair',
-      consensus,
-      source: 'Mesh-Self-Healing'
-    };
-  }
-}
-
-module.exports = new MeshSelfHealer();

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/autonomous/progress-stream.js

@@ -1,49 +0,0 @@
-/**
- * MindForge — Progress Streamer
- * Formats AUDIT events for terminal display and report generation.
- */
-'use strict';
-
-const fs = require('fs');
-
-/**
- * Generate a summary report from an audit file.
- */
-function generateReport(auditPath, phaseNum) {
-  if (!fs.existsSync(auditPath)) return '# No audit log found';
-
-  const lines = fs.readFileSync(auditPath, 'utf8').split('\n').filter(Boolean);
-  const events = lines.map(JSON.parse);
-
-  let report = `# Autonomous Execution Report — Phase ${phaseNum}\n\n`;
-
-  const start = events.find(e => e.event === 'auto_mode_started');
-  const end = events.find(e => e.event === 'auto_mode_completed' || e.event === 'auto_mode_escalated');
-
-  report += '## Summary\n';
-  report += `- **Status**: ${end ? end.event.replace('auto_mode_', '').toUpperCase() : 'IN PROGRESS'}\n`;
-  report += `- **Started**: ${start ? start.timestamp : 'Unknown'}\n`;
-  report += `- **Duration**: ${calculateDuration(start, end)}\n`;
-  report += `- **Tasks Completed**: ${events.filter(e => e.event === 'task_completed').length}\n\n`;
-
-  report += '## Audit Log\n';
-  events.forEach(e => {
-    const time = e.timestamp.split('T')[1].split('.')[0];
-    if (e.event === 'task_completed') report += `- [${time}] ✅ Task ${e.plan} completed\n`;
-    if (e.event === 'node_repair') report += `- [${time}] 🔧 Repair: ${e.repair_type} on ${e.plan} (${e.repair_outcome})\n`;
-    if (e.event === 'stuck_pattern_detected') report += `- [${time}] ⚠️ Stuck Pattern: ${e.pattern} on ${e.file}\n`;
-    if (e.event === 'steering_applied') report += `- [${time}] 🚢 Steering: "${e.instruction}"\n`;
-  });
-
-  return report;
-}
-
-function calculateDuration(start, end) {
-  if (!start || !end) return 'Unknown';
-  const diff = new Date(end.timestamp) - new Date(start.timestamp);
-  const mins = Math.floor(diff / 60000);
-  const secs = Math.floor((diff % 60000) / 1000);
-  return `${mins}m ${secs}s`;
-}
-
-module.exports = { generateReport };