mindforge-cc 3.0.0 → 4.3.0

package/MINDFORGE.md

@@ -1,110 +1,79 @@
-# MINDFORGE.md — Project Constitution
-
-## NON-OVERRIDABLE RULES (read-only — these cannot be changed in MINDFORGE.md)
-
-The following CLAUDE.md behaviors are governance primitives and cannot be
-disabled or overridden by MINDFORGE.md:
-
-- Security auto-trigger for auth/payment/PII changes
-- Plan-first rule (no implementation without a PLAN)
-- Secret detection gate
-- AUDIT writing requirement
-- Critical security and secret-related quality gates
-
-Any attempted override is ignored and logged.
-
-## Parsing rule for multiline values
-Values wrapped in triple quotes are parsed as a verbatim multi-line string from
-the first `"""` to the next `"""`.
-
-## Model validation
-If a configured model is unavailable, fallback to `inherit` and warn.
-
-## Project identity
-NAME=MindForge
-VERSION=2.0.0
-DESCRIPTION=Enterprise agentic framework with Multi-Model Intelligence Layer
-MINDFORGE_VERSION_REQUIRED=2.0.0
-
-## Model preferences
-PLANNER_MODEL=claude-opus-4-5
-EXECUTOR_MODEL=claude-sonnet-4-5
-REVIEWER_MODEL=claude-sonnet-4-5
-VERIFIER_MODEL=claude-sonnet-4-5
-SECURITY_MODEL=claude-opus-4-5
-DEBUG_MODEL=claude-opus-4-5
-RESEARCH_MODEL=gemini-1.5-pro
-QA_MODEL=claude-4-5-sonnet
-QUICK_MODEL=claude-4-5-haiku
-
-## Cost Management
-MODEL_COST_WARN_USD=1.00
-MODEL_COST_HARD_LIMIT_USD=10.00
-MODEL_PREFER_CHEAP_BELOW_DIFFICULTY=2.0
-REQUIRE_CROSS_REVIEW=false
-
-## Execution behavior
-TIER1_AUTO_APPROVE=true
-WAVE_CONFIRMATION_REQUIRED=false
-AUTO_DISCUSS_PHASE=false
-VERIFY_PASS_RATE_WARNING_THRESHOLD=0.75
-COMPACTION_THRESHOLD_PCT=70
-MAX_TASKS_PER_PHASE=15
-
-## Quality standards
-MIN_TEST_COVERAGE_PCT=80
-MAX_FUNCTION_LINES=40
-MAX_CYCLOMATIC_COMPLEXITY=10
-REQUIRE_ADR_FOR_ALL_DECISIONS=false
-BLOCK_ON_MEDIUM_SECURITY_FINDINGS=false
-
-## Skills behavior
-ALWAYS_LOAD_SKILLS=security-review
-DISABLED_SKILLS=
-MAX_FULL_SKILL_INJECTIONS=3
-
-## Governance
-DISCUSS_PHASE_REQUIRED_ABOVE_DIFFICULTY=3.5
-ANTIPATTERN_SENSITIVITY=standard
-BLOCK_ON_HIGH_ANTIPATTERNS=false
-
-## Autonomous mode settings
-AUTO_MODE_DEFAULT_TIMEOUT_MINUTES=120
-AUTO_PUSH_ON_WAVE_COMPLETE=false
-AUTO_NODE_REPAIR_BUDGET=2
-AUTO_PLAN_AMBIGUITY_THRESHOLD=3.5
-SLACK_WEBHOOK_URL=
-
-## Browser Runtime
-BROWSER_PORT=7338
-BROWSER_HEADLESS=true
-DEV_SERVER_URL=http://localhost:3000
-AUTO_RUN_QA_AFTER_UI_WAVES=true
-BROWSER_IDLE_TIMEOUT_MINUTES=30
-AUTO_RUN_UI_REVIEW_AFTER_UI_WAVES=true
-UI_PHASE_ACCESSIBILITY_STANDARD=WCAG_AA
-
-## Project-specific agent instructions
-ADDITIONAL_AGENT_INSTRUCTIONS="""
-- Check packages/shared before creating utilities.
-- Backend middleware semantics follow Fastify conventions.
-- Keep dependency direction one-way from frontend to backend APIs.
-- Prefer date-fns for date manipulation.
-"""
-
-## Project-specific forbidden patterns
-PROJECT_FORBIDDEN_PATTERNS="""
-- No direct DB access from frontend packages
+# MINDFORGE.md — Parameter Registry (v4.1.0-alpha.nexus)
+
+## 1. IDENTITY & VERSIONING
+
+[NAME]    = MindForge
+[VERSION] = 4.2.0-alpha.ztai
+[STABLE]  = false
+[MODE]    = "Zero-Trust Identity"
+[REQUIRED_CORE_VERSION] = 4.2.0
+
+## 2. INTELLIGENCE TOGGLES (V4 UPDATES)
+
+[SWARM_ORCHESTRATION] = true
+[AUTO_SWARM_THRESHOLD] = 7.0
+[CONTEXT7_DEPTH] = "EXTENDED"
+[DYNAMISM_LEVEL] = 5
+[REACTIVE_MODE] = true
+[CONTEXT_SHARDING] = true
+[ADS_LOOP_ENFORCED]  = true
+[TEMPORAL_VISION]    = true
+[RAG_2_AUTO_SHADOW] = true
+[ENABLE_ART_TRACING] = true
+[ENABLE_ZTAI] = true
+[ZTAI_KEY_TYPE] = "Ed25519"
+[NEXUS_TRACE_RETENTION_DAYS] = 30
+
+---
+
+## 3. MODEL TOPOLOGY
+
+# Persona to Model mapping
+[PLANNER]  = claude-opus-4-5
+[EXECUTOR] = claude-sonnet-4-5
+[REVIEWER] = claude-sonnet-4-5
+[VERIFIER] = claude-sonnet-4-5
+[SECURITY] = claude-opus-4-5
+[DEBUG]    = claude-opus-4-5
+[RESEARCH] = gemini-1.5-pro
+[QA]       = claude-4-5-sonnet
+
+---
+
+## 4. GOVERNANCE & ECONOMICS
+
+# Limits and safety gates
+[COST_WARN_USD]       = 2.00
+[COST_HARD_LIMIT_USD] = 25.00
+[ADS_DEBATE_ROUNDS]   = 2
+[MIN_SOUL_SCORE]      = 7.0
+[REQUIRE_ADR]         = true
+[BLOCK_ON_SECURITY]   = true
+
+---
+
+## 5. RESOURCE GEOMETRY
+
+# Paths and ports
+[BROWSER_PORT]    = 7338
+[DASHBOARD_PORT]  = 7339
+[API_URL]         = <http://localhost:3000>
+[SHARD_RETAIN_DAYS] = 7
+
+---
+
+## 6. PROJECT CONSTRAINTS
+
+# Static rules for the agent
+[FORBIDDEN] = """
+- No direct DB access from frontend
 - No synchronous I/O in API handlers
-- No console.log in API services
+- No console.log in production services
 - No TODO comments in committed code
 """
 
-## Self-Building Skills
-AUTO_CAPTURE_SKILLS=false
-AUTO_CAPTURE_MIN_PATTERN_COUNT=2
-AUTO_CAPTURE_MIN_CONFIDENCE=0.75
-LEARN_MODEL=inherit
-MARKETPLACE_REGISTRY=https://registry.mindforge.dev/v1
-MARKETPLACE_DAILY_FETCH_LIMIT=50
-SKILL_QUALITY_MIN_SCORE=60
+[INSTRUCTIONS] = """
+- Check packages/shared before creating utilities.
+- Backend middleware follows Fastify conventions.
+- Date manipulation using date-fns only.
+"""

package/README.md

@@ -1,17 +1,17 @@
-# MindForge — Enterprise Agentic Framework (v3.0.0-rc1)
+# MindForge — Enterprise Agentic Framework (v4.2.5)
 
 MindForge turns Claude Code and Antigravity into production-grade engineering
 partners with governance, observability, and a reactive autonomous intelligence engine.
-Release published: v3.0.0-rc1.
+Release published: v4.1.0-alpha.nexus.
 
 # Install
 ```bash
-npx mindforge-cc@latest
+npx mindforge-cc@v4-alpha
 ```
 
-# Install V3 (Latest)
+# Install V4 (Experimental)
 ```bash
-npm install -g mindforge-cc@latest
+npm install -g mindforge-cc@v4-alpha
 ```
 
 ---
@@ -21,6 +21,10 @@ npm install -g mindforge-cc@latest
 AI coding agents degrade over long sessions. Context fills up. Quality drops.
 Decisions get forgotten. MindForge fixes that with:
 
+- **MindForge Nexus (v4.1)** — High-fidelity **ART** (Agentic Reasoning Tracing) for the agentic mesh
+- **Dynamic Swarm Orchestration (v4)** — parallel "Agentic Mesh" with shared state (v4)
+- **Zero-Trust Identity (v4.2)** — DID-signed non-repudiable audit logs with HSM/Enclave support (v4.2.5)
+- **Global Intelligence Mesh (v4.2)** — Cross-repo knowledge sharing and Ghost Pattern Detection (v4.2.5)
 - **Context Sharding (v3)** — relevance-dense memory management (40% token savings)
 - **Adversarial Synthesis (v3)** — zero-drift logic through red/blue model debate
 - **Temporal Vision (v3)** — full history scrubbing and hindsight state repair
@@ -343,17 +347,31 @@ See `.mindforge/production/token-optimiser.md`.
 
 ---
 
-## What's new in v3.0.0-rc1
+---
+
+## What's new in v4.2 (Intelligence Mesh)
+
+MindForge V4.2 focuses on **Identity** and **Memory** within the agentic swarm.
+
+- **ZTAI Beast Mode**: Every agent action is cryptographically signed using asymmetric keys. Tier 3 agents use a simulated **Secure Enclave (HSM)** for top-level non-repudiation.
+- **Audit Integrity**: High-fidelity audit manifests generated with **Merkle-root** cumulative hash chains.
+- **Semantic Hub**: Synchronization between local repository memory and the global organizational store (`~/.mindforge/`).
+- **Ghost Pattern Detection**: Proactive risk detection that warns agents when a proposed design matches a past organizational failure.
 
-🚀 **The Reactive Intelligence Era**
+## What's new in v4.1 (Nexus)
 
-MindForge V3 transforms the framework from a "disciplined workflow engine" into a **Reactive Autonomous Intelligence**.
+🚀 **The High-Fidelity Observability Era**
+
+MindForge V4.1 introduces **Nexus**, the definitive observability layer for autonomous agents.
+
+- **Agentic Reasoning Tracing (ART)**: Deep visibility into "thought chains" and parallel mesh reasoning via hierarchical spans.
+- **Trace Context Propagation**: OpenTelemetry-compatible trace IDs across waves, tasks, and swarm clusters.
+- **Reasoning Heatmaps**: Automated visualization of adversarial disagreement and consensus synthesis.
+- **Mesh Visibility**: Live tracing of ephemeral specialist clusters in the agentic mesh.
+
+---
 
-- **Context Sharding (SRD)**: Achieve a **40% reduction in token waste** via relevance-dense memory management.
-- **Adversarial Decision Synthesis (ADS)**: Zero-drift architectural logic through a 3-model debate and SOUL-scoring engine.
-- **Temporal Vision**: Full-fidelity history navigation, hindsight state injection, and automated repair.
-- **RAG 2.0 (Auto-Shadowing)**: Background pattern retrieval from the local knowledge graph without manual prompts.
-- **V3 Core Guide**: New definitive architecture guide in `docs/architecture/V3-CORE.md`.
+## What's new in v4.0.0 (Swarm)
 
 ---
 

package/RELEASENOTES.md

@@ -1,41 +1,46 @@
-# MindForge v2.1.1 — Core Migration & Persona Expansion
+# MindForge v4.3.0 — Enterprise Mesh & Proactive Equilibrium
 
 ## Top Summary
-
-MindForge v2.1.1 is a major structural update that finalizes the migration of the MindForge framework into the MindForge ecosystem. This release establishes a unified `.agent/` asset structure, expands the persona count from 8 to 32+, and hardens the 4-pillar workflow (`plan`, `execute`, `verify`, `ship`) for enterprise-scale AI orchestration.
+MindForge v4.3.0 introduces the **Enterprise Intelligence Mesh**, finalizing the v4 roadmap with autonomous FinOps and self-healing reliability. This release also implements **ZTAI Beast Mode**, hardens agentic identity with asymmetric cryptographic signing, and introduces simulated Secure Enclaves (HSM) for Tier 3 principal agents.
 
 ## Highlights
 
-- **Unified .agent/ Structure**: 120+ framework assets consolidated for maximum compatibility across Claude Code, Antigravity, and Cursor.
-- **32-Persona Expansion**: Integrated advanced personas including `advisor-researcher`, `nyquist-auditor`, and `ui-auditor`.
-- **Zero-Watermark Integrity**: 100% removal of legacy rebranding fragments across the entire core and documentation.
-- **Enterprise Manifest**: Single source of truth via `file-manifest.json` for multi-project codebase intelligence.
-- **Hardened Governance**: Unified settings and non-bypassable quality gates across all runtimes.
+- **Pillar V: Autonomous FinOps Hub**: Dynamic **C2C (Confidence-to-Cost)** model routing and real-time Agentic ROI tracking.
+- **Pillar VI: Proactive Equilibrium**: Real-time **Wave Divergence** monitoring and autonomous **Temporal Hindsight** repair loops.
+- **Global Intelligence Mesh**: Synchronizes local project memory with a repository-agnostic organizational store (`~/.mindforge/`).
+- **Ghost Pattern Detection**: Proactive risk detection that warns agents when a proposed design matches a past organizational failure.
+- **ZTAI Beast Mode**: Every agent action in the mesh is now cryptographically signed using Ed25519 asymmetric keys.
+- **Secure Enclave (HSM) Simulation**: Tier 3 agents (Principal/Architect) now use simulated hardware-secured enclaves for signing.
+- **Audit Integrity Manifests**: Automated generation of Merkle-root based manifests for the `AUDIT.jsonl` log.
+- **Tiered Governance**: Full integration of Trust Tiers [0-3] across the 32-persona library.
 
 ## Developer Experience
 
-- **Consolidated Documentation**: Modernized guides for Skills Authoring, Architecture, and Persona-based engineering.
-- **Enhanced Hooks**: New lifecycle hooks for better context monitoring and real-time status reporting.
-- **Command Parity**: Full support for `/mindforge:browse`, `/mindforge:remember`, and `/mindforge:costs`.
+- **New Command Hooks**: Integration of `semantic-hub` and `ztai-archiver` into the core planning and execution loops.
+- **Enhanced PERSONAS.md**: Detailed trust-tier mappings for all specialists.
+- **Proactive Risk Warnings**: Real-time "Ghost Pattern" matches surfaced during the `/mindforge:plan-phase` process.
 
 ## Quality & Stability
 
-- **Grep-Audit Verified**: Verified zero residual branding through recursive deep scanning.
-- **Path-Aligned Workflows**: All 60+ workflows now strictly follow the v2.1.1 directory standards.
-- **Cross-IDE Tested**: Core features validated across multiple AI-native IDE runtimes.
+- **Verified Identity**: 100% of Tier 3 actions require valid cryptographic signatures.
+- **Tamper-Detection**: Audit manifestations allow for historical integrity verification of the entire session.
+- **Cross-Repo Intelligence**: Validated knowledge sharing between isolated project workspaces via the Semantic Hub.
 
-## Getting Started
+## Upgrade Notes
 
-- Install: `npx mindforge-cc@latest --claude --local`
-- Verify Health: `/mindforge:health`
-- Docs Entry: `README.md`
+- Projects on v4.1.0 should run `/mindforge:update --apply` to enable the ZTAI and Mesh features.
+- Initial global sync will occur automatically upon the first `plan-phase` or `execute-phase`.
+- Legacy memory stores will be semantically indexed for the global store during the first sync.
 
-## Upgrade Notes
+---
 
-- Projects on v1.0.0 or v2.0.0 should run `/mindforge:migrate` to align with the new path standards.
-- Residual custom skills in legacy folders may need manual relocation to `.agent/skills/`.
+# MindForge v4.1.0 — Nexus & High-Fidelity Observability
 
-## Breaking Changes
+## Highlights
+- **MindForge Nexus**: Agentic Reasoning Tracing (ART) for deep visibility into thought chains.
+- **Trace Context Propagation**: OpenTelemetry-compatible tracing across parallel waves and swarm clusters.
+
+---
 
-- Legacy `.agent/workflows` (without YAML frontmatter) is no longer automatically registered in Antigravity mode.
-- See `docs/upgrade.md` for detailed migration paths.
+# MindForge v2.1.1 — Core Migration & Persona Expansion
+...

package/bin/engine/feedback-loop.js

@@ -0,0 +1,71 @@
+/**
+ * MindForge — WaveFeedbackLoop (Pillar VI: Proactive Equilibrium)
+ * Monitors divergence during wave execution and triggers self-healing.
+ */
+
+class WaveFeedbackLoop {
+  constructor(config = {}) {
+    this.failureThreshold = config.failureThreshold || 0.20; // 20% failure rate
+    this.divergenceWeight = config.divergenceWeight || 1.5; // Bias for rapid divergence
+    this.waveState = {
+      completed: 0,
+      failed: 0,
+      skipped: 0,
+      total: 0,
+    };
+  }
+
+  /**
+   * Updates the feedback loop with a task result.
+   */
+  update(result) {
+    this.waveState.total++;
+    if (result.status === 'completed') {
+      this.waveState.completed++;
+    } else if (result.status === 'failed') {
+      this.waveState.failed++;
+    } else {
+      this.waveState.skipped++;
+    }
+  }
+
+  /**
+   * Calculates the current divergence rate.
+   * @returns {number} - 0.0 to 1.0 divergence rate.
+   */
+  calculateDivergence() {
+    if (this.waveState.total === 0) return 0;
+    const failureRate = this.waveState.failed / this.waveState.total;
+    const skippedRate = this.waveState.skipped / this.waveState.total;
+    
+    // Divergence includes failures and unexpected skips
+    return (failureRate + (skippedRate * 0.5));
+  }
+
+  /**
+   * Determines if the wave is "Diverging" and needs autonomous recovery.
+   * @returns {Object} - Result (shouldPause, reason)
+   */
+  shouldTriggerHindsight() {
+    const divergence = this.calculateDivergence();
+    const minSample = 5; // Start checking after 5 tasks to avoid noise
+
+    if (this.waveState.total < minSample) return { shouldPause: false };
+
+    if (divergence >= this.failureThreshold) {
+      return {
+        shouldPause: true,
+        divergence: divergence.toFixed(2),
+        reason: `Wave Divergence reached critical threshold (${(divergence * 100).toFixed(0)}%). Triggering Temporal Hindsight for RCA and repair.`,
+      };
+    }
+
+    return { shouldPause: false };
+  }
+
+  reset() {
+    this.waveState = { completed: 0, failed: 0, skipped: 0, total: 0 };
+  }
+}
+
+module.exports = WaveFeedbackLoop;

package/bin/engine/nexus-tracer.js

@@ -0,0 +1,150 @@
+/**
+ * MindForge Nexus — Core Tracer Engine (v4.1.0-alpha.nexus)
+ *
+ * Handles Agentic Reasoning Tracing (ART) spans and OpenTelemetry-compatible 
+ * trace context propagation across the agentic mesh.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const ztai = require('../governance/ztai-manager');
+
+class NexusTracer {
+  constructor(config = {}) {
+    this.projectId = config.projectId || 'mindforge-nexus';
+    this.auditPath = config.auditPath || path.join(process.cwd(), '.planning', 'AUDIT.jsonl');
+    this.currentTraceId = null;
+    this.activeSpans = new Map();
+    this.did = config.did || null; // Active Agent DID
+    this.enableZtai = config.enableZtai !== false;
+  }
+
+  /**
+   * Initialize or resume a trace.
+   */
+  startTrace(traceId = null) {
+    this.currentTraceId = traceId || `tr_${crypto.randomBytes(8).toString('hex')}`;
+    return this.currentTraceId;
+  }
+
+  /**
+   * Start a new ART span.
+   */
+  startSpan(name, attributes = {}, parentSpanId = null) {
+    const spanId = `sp_${crypto.randomBytes(6).toString('hex')}`;
+    const startTime = new Date().toISOString();
+
+    const span = {
+      id: spanId,
+      trace_id: this.currentTraceId,
+      parent_id: parentSpanId || null,
+      name,
+      status: 'active',
+      start_time: startTime,
+      attributes: {
+        ...attributes,
+        service: 'mindforge-nexus',
+      }
+    };
+
+    this.activeSpans.set(spanId, span);
+
+    // Record span start in AUDIT.jsonl
+    this._recordEvent('span_started', { 
+      span_id: spanId, 
+      parent_span_id: parentSpanId,
+      span_name: name,
+      ...attributes 
+    });
+
+    return spanId;
+  }
+
+  /**
+   * End an active span.
+   */
+  endSpan(spanId, status = 'success', metadata = {}) {
+    const span = this.activeSpans.get(spanId);
+    if (!span) return;
+
+    span.status = status;
+    span.end_time = new Date().toISOString();
+    
+    this._recordEvent('span_completed', {
+      span_id: spanId,
+      status,
+      ...metadata
+    });
+
+    this.activeSpans.delete(spanId);
+  }
+
+  /**
+   * Record a Reasoning Trace event (ART granularity).
+   */
+  recordReasoning(spanId, agent, thought, resolution = 'none') {
+    this._recordEvent('reasoning_trace', {
+      span_id: spanId,
+      agent,
+      thought,
+      resolution
+    });
+  }
+
+  /**
+   * Internal AUDIT writer.
+   */
+  _recordEvent(event, data) {
+    const entry = {
+      id: crypto.randomUUID(),
+      timestamp: new Date().toISOString(),
+      event,
+      trace_id: this.currentTraceId,
+      ...data
+    };
+
+    // ZTAI Signing Logic
+    if (this.enableZtai && this.did) {
+      try {
+        entry.did = this.did;
+        // Sign the stringified entry WITHOUT the signature field itself
+        const payload = JSON.stringify(entry);
+        entry.signature = ztai.signData(this.did, payload);
+      } catch (err) {
+        console.warn(`[NexusTracer] ZTAI signing failed: ${err.message}`);
+      }
+    }
+
+    try {
+      if (!fs.existsSync(path.dirname(this.auditPath))) {
+        fs.mkdirSync(path.dirname(this.auditPath), { recursive: true });
+      }
+      fs.appendFileSync(this.auditPath, JSON.stringify(entry) + '\n');
+    } catch (err) {
+      console.error(`[NexusTracer] Failed to write audit entry: ${err.message}`);
+    }
+  }
+
+  /**
+   * Records a FinOps budget decision (Pillar V).
+   */
+  recordFinOps(spanId, decision) {
+    this._recordEvent('finops_decision', {
+      span_id: spanId,
+      ...decision
+    });
+  }
+
+  /**
+   * Records a Self-Healing trigger event (Pillar VI).
+   */
+  recordSelfHeal(spanId, report) {
+    this._recordEvent('self_heal_trigger', {
+      span_id: spanId,
+      ...report
+    });
+  }
+}
+
+module.exports = NexusTracer;

package/bin/engine/temporal-hindsight.js

@@ -0,0 +1,88 @@
+/**
+ * MindForge — TemporalHindsight (Pillar VI: Proactive Equilibrium)
+ * Performs automated RCA and generates repair plans for diverging waves.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class TemporalHindsight {
+  constructor(config = {}) {
+    this.projectRoot = config.projectRoot || process.cwd();
+    this.historyLimit = config.historyLimit || 10; // Analyze last 10 failed tasks
+  }
+
+  /**
+   * Performs Root Cause Analysis (RCA) on a failed wave.
+   * @param {Object} waveReport - Current wave results (failed tasks, logs)
+   * @returns {Object} - Diagnosis and Repair Plan
+   */
+  async analyze(waveReport) {
+    const { failedTasks, divergence, phase } = waveReport;
+    const diagnosis = this.diagnoseFailures(failedTasks);
+    
+    return {
+      timestamp: new Date().toISOString(),
+      phase,
+      divergence,
+      diagnosis,
+      repairPlan: this.generateRepairPlan(diagnosis, phase),
+    };
+  }
+
+  /**
+   * Diagnoses common failure patterns in agentic workloads.
+   */
+  diagnoseFailures(tasks) {
+    const errorMessages = tasks.map(t => t.error || '').join(' ').toLowerCase();
+    
+    if (errorMessages.includes('permission denied') || errorMessages.includes('eacces')) {
+      return { type: 'ENVIRONMENTAL', cause: 'File system permission issues detected in multiple tasks.', severity: 'CRITICAL' };
+    }
+    
+    if (errorMessages.includes('timeout') || errorMessages.includes('deadline exceeded')) {
+      return { type: 'RESOURCE', cause: 'Wave execution timeout. Tasks are too large or the model response is slow.', severity: 'HIGH' };
+    }
+    
+    if (errorMessages.includes('lint') || errorMessages.includes('syntax error')) {
+      return { type: 'LOGIC', cause: 'Cumulative coding errors. The existing plan is producing invalid syntax consistently.', severity: 'STRICT' };
+    }
+
+    return { type: 'UNKNOWN', cause: 'Generic wave divergence. Multiple unrelated failures detected.', severity: 'MEDIUM' };
+  }
+
+  /**
+   * Generates a "Self-Healing" Plan.md entry.
+   */
+  generateRepairPlan(diagnosis, phase) {
+    const steps = [];
+    
+    switch (diagnosis.type) {
+      case 'ENVIRONMENTAL':
+        steps.push('PAUSE execution immediately.');
+        steps.push('Run `chmod -R u+w .` (simulated) on the affected directories.');
+        steps.push('Re-verify task 0.1 before resuming the wave.');
+        break;
+      case 'RESOURCE':
+        steps.push('PAUSE execution and increase `taskTimeoutMs` by 50%.');
+        steps.push('Request `EXECUTOR_MODEL` upgrade to `claude-3-opus` for complex tasks.');
+        steps.push('Serialise the next wave (concurrency = 1) to reduce resource contention.');
+        break;
+      case 'LOGIC':
+        steps.push('STOP active wave.');
+        steps.push('Rewrite Sub-tasks in PLAN.md for Phase ' + phase + ' with stricter TDD requirements.');
+        steps.push('Inject `Quality-Auditor` persona into the review loop.');
+        break;
+      default:
+        steps.push('PAUSE and request human review for divergence RCA.');
+    }
+    
+    return {
+      title: `AUTONOMOUS REPAIR PLAN: PHASE ${phase}`,
+      steps,
+      autoApplyStatus: 'PENDING_SIGNATURE',
+    };
+  }
+}
+
+module.exports = TemporalHindsight;