mindforge-cc 8.1.1 → 8.2.0

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

@@ -0,0 +1,378 @@
+/**
+ * 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

@@ -0,0 +1,64 @@
+/**
+ * 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

@@ -0,0 +1,36 @@
+/**
+ * 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

@@ -0,0 +1,80 @@
+/**
+ * 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

@@ -0,0 +1,67 @@
+/**
+ * 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

@@ -0,0 +1,49 @@
+/**
+ * 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 };