mindforge-cc 10.7.0 → 11.0.0

package/.mindforge/MINDFORGE-V2-SCHEMA.json

@@ -1,14 +1,51 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "MindForge v2 Autonomous Engine Schema",
-  "description": "Schema for HANDOFF.json and auto-state.json in v2.0.0-alpha.1",
+  "description": "Schema for HANDOFF.json and auto-state.json in v2.0.0-alpha.1+",
   "type": "object",
   "properties": {
-    "schema_version": { "type": "string", "const": "2.0.0" },
+    "schema_version": { "type": "string" },
+    "schema_type": { "type": "string", "enum": ["HANDOFF", "AUTO_STATE"] },
     "auto_mode_active": { "type": "boolean" },
-    "phase": { "type": "integer" },
-    "wave_current": { "type": "integer" },
-    "tasks_completed": { "type": "integer" },
+    "phase": { "oneOf": [{ "type": "integer" }, { "type": "string" }] },
+    "wave_current": { "type": "integer", "minimum": 0 },
+    "tasks_completed": { "type": "integer", "minimum": 0 },
+    "status": {
+      "type": "string",
+      "enum": ["idle", "running", "paused", "completed", "escalated", "timeout"]
+    },
+    "handoffs": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "id": { "type": "string" },
+          "name": { "type": "string" },
+          "plan": { "type": "string" },
+          "depends_on": {
+            "type": "array",
+            "items": { "type": "string" }
+          },
+          "wave": { "type": "integer", "minimum": 0 }
+        },
+        "required": ["id", "name"]
+      }
+    },
+    "timestamps": {
+      "type": "object",
+      "properties": {
+        "started_at": { "type": "string", "format": "date-time" },
+        "updated_at": { "type": "string", "format": "date-time" }
+      }
+    },
+    "next_task": { "type": "string" },
+    "context_refs": { "type": "array", "items": { "type": "string" } },
+    "blockers": { "type": "array", "items": { "type": "string" } },
+    "decisions_needed": { "type": "array", "items": { "type": "string" } },
+    "recent_commits": { "type": "array", "items": { "type": "string" } },
+    "recent_files": { "type": "array", "items": { "type": "string" } },
+    "current_context": { "type": "string" },
+    "last_updated": { "type": "string", "format": "date-time" },
     "PLANNER_MODEL": { "type": "string" },
     "EXECUTOR_MODEL": { "type": "string" },
     "REVIEWER_MODEL": { "type": "string" },
@@ -21,10 +58,6 @@
     "MODEL_COST_HARD_LIMIT_USD": { "type": "number" },
     "MODEL_PREFER_CHEAP_BELOW_DIFFICULTY": { "type": "number" },
     "REQUIRE_CROSS_REVIEW": { "type": "boolean" },
-    "status": {
-      "type": "string",
-      "enum": ["idle", "running", "paused", "completed", "escalated", "timeout"]
-    },
     "governance": {
       "type": "object",
       "properties": {
@@ -43,5 +76,5 @@
       }
     }
   },
-  "required": ["schema_version", "auto_mode_active", "status"]
+  "required": ["schema_version"]
 }

package/.mindforge/config.json

@@ -5,7 +5,7 @@
     "drift_threshold": 0.75,
     "critical_drift_threshold": 0.5,
     "res_threshold": 0.8,
-    "active_did": "did:mindforge:5a537f83-69de-40ac-a613-e96d4a84a270"
+    "active_did": "did:mindforge:da5daf83-c478-490f-b528-bd907ad4eee3"
   },
   "revops": {
     "market_registry": {
@@ -69,6 +69,11 @@
     "max_drift_threshold": 0.1,
     "auto_verify": false
   },
+  "wave_concurrency": 3,
+  "temporal": {
+    "max_snapshots": 50,
+    "max_age_days": 7
+  },
   "instincts": {
     "mode": "auto-capture",
     "max_active_per_project": 100,

package/CHANGELOG.md

@@ -1,5 +1,69 @@
 # Changelog
 
+## [11.0.0] - 2026-05-28 — "Sovereign Stability"
+
+### Breaking Changes
+
+- `verifyZKProof()` returns structured `{ verified, reason }` instead of throwing
+- `signPQ()` returns `{ signature, simulated, algorithm }` object instead of raw string
+- Wave task execution order within waves is no longer deterministic
+- SDK bumped to 11.0.0 with new type exports
+- Dashboard tokens now expire after 24 hours
+- `TemporalHub.captureState()` and `rollbackTo()` are now async
+
+### Added
+
+- LRUMap utility class for bounded caches with eviction callbacks
+- Atomic JSON write primitives (write-to-temp, fsync, rename)
+- AUDIT.jsonl log rotation with gzip archival (max 5000 lines)
+- HANDOFF.json structural validation (fail-open)
+- Temporal snapshot garbage collection (retain 50, expire > 7 days)
+- BM25 scoring with document-length normalization
+- Persistent index cache (mtime-based invalidation)
+- Persistent adjacency index for knowledge graph
+- Correction effectiveness tracking in self-corrective synthesizer
+- Full remediation strategy implementations (CONTEXT_COMPRESSION, GOLDEN_TRACE_INJECTION, REASONING_RESTART)
+- Graduated intelligence interlock (+1/+2/MAX tier) with cost-awareness
+- 3-tier stuck detection (hash → length → truncated Levenshtein)
+- Adaptive context window (10/20/30 based on velocity)
+- Configurable external ZK verifier module path
+- Ephemeral SRE enclave keys (crypto.randomBytes)
+- Time-limited RBAC role elevation with auto-expiry
+- Session-scoped ZTAI agent registry
+- Dashboard rate limiting (100 req/min/IP) and token expiration (24h)
+- /api/v1/token/refresh endpoint
+- Optional GPG approval verification
+- GET /api/v1/system observability endpoint (heap, uptime, audit stats)
+- checkHeapHealth() with warning/critical thresholds
+- Remediation effectiveness persistence
+- Model router dynamic reload (mtime-based, 60s interval)
+- P95 latency ring buffer for cloud broker
+- EIS client with real fetch + 3-retry exponential backoff
+- Semaphore-based parallel wave execution (max concurrency configurable)
+- WebSocketEventStream with auto-reconnect
+- SDK streamExecution() with AsyncIterable<StreamChunk>
+- SDK batchExecute() with concurrent task execution
+- SDK validateRuntimeConfig()
+- Model streaming support (Anthropic, OpenAI, Gemini providers)
+- Migration script (bin/migrations/10.7.0-to-11.0.0.js)
+
+### Changed
+
+- sessionDriftHistory bounded to 500 entries via LRUMap
+- entropyCache bounded to 1000 entries via LRUMap
+- Cloud broker failure tracking uses 5-minute sliding window
+- Self-corrective synthesizer window expanded from 10 → 50 events
+- Context refactorer uses adaptive window instead of fixed 20
+
+### Fixed
+
+- Memory leaks from unbounded Maps in long-running sessions
+- Data corruption risk on process crash during state file writes
+- Disk exhaustion from unbounded AUDIT.jsonl and snapshot growth
+- Hardcoded SRE enclave private key (security issue)
+
+---
+
 ## [10.7.0] - 2026-05-27 — "Platform Sovereign"
 
 ### Added (v10.7.0)

package/MINDFORGE.md

@@ -1,12 +1,12 @@
-# MINDFORGE.md — Parameter Registry (v10.7.0)
+# MINDFORGE.md — Parameter Registry (v11.0.0)
 
 ## 1. IDENTITY & VERSIONING
 
 [NAME]    = MindForge
-[VERSION] = 10.7.0-SOVEREIGN
+[VERSION] = 11.0.0
 [STABLE]  = true
 [MODE]    = "Platform Sovereign"
-[REQUIRED_CORE_VERSION] = 10.7.0
+[REQUIRED_CORE_VERSION] = 11.0.0
 [SOVEREIGN_IDENTITY] = true
 [SRE_LAYER_ENABLED]  = true
 

package/README.md

@@ -1,12 +1,21 @@
 # MindForge
 
-**An agentic intelligence framework for Claude Code** — orchestrates multi-agent workflows with governance, memory, and autonomous execution. Install once, get structured AI-driven development with built-in quality gates.
+**An agentic intelligence framework for Claude Code** — orchestrates multi-agent workflows with governance, memory, and autonomous execution. Production-hardened with true parallelism, streaming SDK, and zero-trust security. Install once, get structured AI-driven development with built-in quality gates.
 
 ---
 
-## v10.0.3 — Council Awakens
+## v11.0.0 — Sovereign Stability
 
-MindForge v10.0.3 "Council Awakens" introduces the Council decision framework, Instinct Engine, Cost-Aware Routing, 6-phase Verification Loop, and Multi-LLM Consult. This release adds 10 skills (20 core total), 8 commands (71 total), 9 personas (117 total), 3 swarm templates (21 total), and 5 engine subsystems — expanding MindForge's autonomous governance and multi-agent reasoning capabilities.
+MindForge v11.0.0 "Sovereign Stability" is a production-hardening release focused on reliability, performance, and real-world deployment readiness. Key highlights:
+
+- **Memory-safe operations** — LRU-bounded caches, atomic writes, log rotation, and snapshot garbage collection eliminate resource leaks in long-running sessions.
+- **True wave parallelism** — Semaphore-based concurrent execution with configurable max concurrency replaces sequential task dispatch.
+- **Streaming SDK** — WebSocket event streaming, `streamExecution()` with AsyncIterable, and `batchExecute()` for high-throughput integrations.
+- **Hardened security** — Ephemeral enclave keys, session-scoped agent isolation, time-limited RBAC elevation, dashboard rate limiting, and structured ZK proof returns.
+- **Production observability** — `/api/v1/system` health endpoint, P95 latency tracking, heap health monitoring, and real EIS client with retry logic.
+- **Graduated intelligence** — Adaptive tier escalation (+1/+2/MAX) with cost-awareness, 3-tier stuck detection, and adaptive context windows.
+
+This release ships 200+ skills, 400+ personas, 18 pillars, and 49 swarm templates across 12 engineering domains.
 
 
 ## Installation & Setup
@@ -45,6 +54,12 @@ npx mindforge-cc@latest --antigravity --local
 
 ---
 
+- **Production Hardening (v11.0.0)** — LRU caches, atomic JSON writes, log rotation, HANDOFF validation, and temporal snapshot GC for crash-safe long-running sessions.
+- **True Wave Parallelism (v11.0.0)** — Semaphore-based concurrent wave execution with configurable max concurrency replaces sequential dispatch.
+- **Streaming SDK (v11.0.0)** — WebSocket event streaming, `streamExecution()` AsyncIterable, `batchExecute()`, model streaming across Anthropic/OpenAI/Gemini providers.
+- **Graduated Intelligence (v11.0.0)** — Adaptive tier escalation (+1/+2/MAX) with cost-awareness, 3-tier stuck detection, and adaptive context windows (10/20/30).
+- **Security Hardening (v11.0.0)** — Ephemeral enclave keys, session-scoped ZTAI, time-limited RBAC elevation, dashboard rate limiting (100 req/min/IP), token expiration.
+- **Observability (v11.0.0)** — `/api/v1/system` health endpoint, P95 latency ring buffer, heap health monitoring, real EIS client with exponential backoff.
 - **Grounded Wave Execution (v9.0.0)** — AutoRunner reads HANDOFF.json wave groups, dispatches tasks with audit tracing, persists progress, and resumes on restart (Pillar XXIV).
 - **Model Topology Modernization (v9.0.0)** — All model references updated to the Claude 4.x family: claude-opus-4-7, claude-sonnet-4-6, claude-haiku-4-5 (Pillar XXV).
 - **Unified Memory Architecture (v9.0.0)** — Knowledge and graph edges consolidated into SQLite (celestial.db) with FTS5 search. Four JSONL stores replaced by one queryable store (Pillar XXVI).
@@ -272,7 +287,7 @@ MindForge supports multiple interaction models to fit your engineering workflow:
 ```bash
 /mindforge:update
 /mindforge:update --apply
-/mindforge:migrate --from v0.6.0 --to v1.0.0
+/mindforge:migrate --from v10.7.0 --to v11.0.0
 ```
 
 ---
@@ -320,6 +335,36 @@ See `.mindforge/production/token-optimiser.md`.
 
 ## 📜 Framework Evolution & Version History
 
+<details>
+<summary><b>v11.0.0 — Sovereign Stability (Production Hardening)</b></summary>
+
+- **Phase 1: Foundation** — LRU-bounded caches, atomic JSON writes, AUDIT.jsonl log rotation, HANDOFF.json structural validation, temporal snapshot garbage collection.
+- **Phase 2: Intelligence** — BM25 scoring with document-length normalization, full remediation strategy implementations, graduated intelligence interlock (+1/+2/MAX), 3-tier stuck detection, adaptive context windows.
+- **Phase 3: Security** — Structured ZK proof returns, ephemeral SRE enclave keys, session-scoped ZTAI agent registry, time-limited RBAC elevation, dashboard rate limiting and token expiration, optional GPG approval verification.
+- **Phase 4: Observability** — Async temporal I/O, `/api/v1/system` health endpoint, P95 latency ring buffer, heap health monitoring, EIS client de-stub with real fetch and retry logic.
+- **Phase 5: SDK/Distributed** — Semaphore-based wave parallelism, WebSocket event streaming with auto-reconnect, `batchExecute()`, model streaming (Anthropic/OpenAI/Gemini), migration script from v10.7.0.
+</details>
+
+<details>
+<summary><b>v10.x — The 200-Skills Expansion (Council → Platform Sovereign)</b></summary>
+
+- **Council Awakens (v10.0.3)**: Council decision framework, Instinct Engine, Cost-Aware Routing, 6-phase Verification Loop, Multi-LLM Consult.
+- **Skills Expansion (v10.0.4–v10.7.0)**: From 20 to 200+ core skills across 12 domains — AI/ML, data engineering, platform engineering, mobile, leadership, industry verticals, and more.
+- **400+ Personas**: Comprehensive specialist coverage with domain-expert identity protocols.
+- **49 Swarm Templates**: Task-aware parallel specialist clusters covering every engineering discipline.
+</details>
+
+<details>
+<summary><b>v9.x — Grounded Execution & SQLite Persistence</b></summary>
+
+- **Grounded Wave Execution (Pillar XXIV)**: AutoRunner reads HANDOFF.json wave groups with audit tracing and restart persistence.
+- **Model Topology Modernization (Pillar XXV)**: Claude 4.x family (opus-4-7, sonnet-4-6, haiku-4-5).
+- **Unified Memory Architecture (Pillar XXVI)**: SQLite (celestial.db) with FTS5 search replacing JSONL stores.
+- **Schema Migration Engine (Pillar XXVII)**: Versioned migration tracking with transaction-wrapped imports.
+- **Integration Test Chain (Pillar XXVIII)**: 27-assertion end-to-end pipeline validation.
+</details>
+
+<details>
 <summary><b>v8.1.x — Sovereign Identity (Pillar XIX)</b></summary>
 
 - **Pillar XIX: Sovereign Identity Synthesis**: Autonomous creation and evolution of `SOUL.md` from execution traces.

package/RELEASENOTES.md

@@ -1,3 +1,83 @@
+# Release Notes — v11.0.0 "Sovereign Stability"
+
+**Release Date**: 2026-05-28  
+**Type**: Major (breaking changes)  
+**Upgrade Path**: Run `node bin/migrations/10.7.0-to-11.0.0.js`
+
+## Highlights
+
+MindForge v11.0.0 is a production-hardening release that addresses systemic stability, intelligence, security, and SDK capabilities. It eliminates memory leaks, adds crash-safe writes, upgrades semantic search from TF-IDF to BM25, completes previously-stubbed subsystems, and introduces true parallel execution.
+
+## What's New
+
+### Foundation Hardening
+- **Bounded caches** — LRUMap prevents unbounded memory growth in drift detector, entropy cache, and failure tracking
+- **Atomic writes** — State files use write-to-temp → fsync → rename (crash-safe)
+- **Log rotation** — AUDIT.jsonl auto-archives beyond 5000 lines with gzip compression
+- **Schema validation** — HANDOFF.json validated on load (fail-open with warnings)
+- **Snapshot GC** — Temporal history auto-cleaned (retain 50, expire > 7 days)
+
+### Intelligence Upgrades
+- **BM25 scoring** — Document-length-normalized search replacing raw TF-IDF
+- **Persistent caching** — Index and adjacency caches eliminate O(n) rebuilds
+- **Complete remediation** — All three strategies fully implemented (no more stubs)
+- **Adaptive systems** — Intelligence tier, context window, and stuck detection all auto-tune
+
+### Security Hardening
+- **Ephemeral enclave keys** — No more hardcoded secrets in source
+- **Structured crypto boundaries** — Simulated vs real clearly marked
+- **Session isolation** — RBAC elevation with TTL, session-scoped identity
+- **Dashboard security** — Token expiration, rate limiting, refresh endpoint
+
+### Observability
+- **System metrics** — `/api/v1/system` with heap monitoring and alerts
+- **P95 latency tracking** — Real measurements replace hardcoded values
+- **Effectiveness tracking** — Remediations measured for closed-loop improvement
+- **Dynamic config reload** — Model router refreshes on MINDFORGE.md changes
+
+### SDK & Distributed
+- **True parallelism** — Wave tasks execute concurrently via semaphore
+- **WebSocket streaming** — Real-time event delivery with auto-reconnect
+- **Batch execution** — Execute multiple tasks with concurrency control
+- **Model streaming** — Anthropic, OpenAI, and Gemini streaming support
+
+## Breaking Changes
+
+| Change | Impact | Migration |
+|--------|--------|-----------|
+| `verifyZKProof()` returns structured result | Code catching throws will miss denials | Check `result.verified` instead |
+| `signPQ()` returns object | Code using return value as string will break | Destructure `{ signature }` from result |
+| Wave execution non-deterministic | Task order within waves no longer guaranteed | Do not rely on execution order |
+| `captureState()`/`rollbackTo()` now async | Callers must await these methods | Add `await` at all call sites |
+| Dashboard tokens expire after 24h | Long-lived tokens stop working | Use `/api/v1/auth/refresh` endpoint |
+| SDK bumped to 11.0.0 | New exports, removed deprecated paths | Update `mindforge-sdk@11.0.0` |
+
+See upgrade guide at `docs/upgrade.md` for full migration steps.
+
+## Migration
+
+```bash
+node bin/migrations/10.7.0-to-11.0.0.js
+```
+
+The migration script:
+1. Backs up `.mindforge/config.json`
+2. Adds new config sections (temporal, rate_limiting, session, wave_execution)
+3. Archives old AUDIT.jsonl entries if > 5000 lines
+4. Runs temporal snapshot GC
+5. Bumps schema versions
+
+---
+
+## Previous Releases
+
+- [v10.0.3 — Council Awakens](https://github.com/sairam0424/MindForge/releases/tag/v10.0.3)
+- [v10.0.1 — Bedrock Fortified](https://github.com/sairam0424/MindForge/releases/tag/v10.0.1)
+- [v9.0.0 — Bedrock Meridian](https://github.com/sairam0424/MindForge/releases/tag/v9.0.0)
+
+---
+---
+
 # Release Notes — v10.0.3 "Council Awakens"
 
 **Release Date**: 2026-05-25  

package/SECURITY.md

@@ -4,12 +4,12 @@
 
 | Version | Status | Support Level |
 |---------|--------|---------------|
-| 10.x | **Current** | Full security and feature updates |
-| 9.x | Maintenance | Critical security patches only (until 2026-08-31) |
-| 8.x | End of Life | No further updates |
-| 7.x and below | End of Life | No further updates |
+| 11.x | **Current** | Full security and feature updates |
+| 10.x | Maintenance | Critical security patches only (until 2026-11-30) |
+| 9.x | End of Life | No further updates |
+| 8.x and below | End of Life | No further updates |
 
-We recommend all users upgrade to the latest 10.x release. Security patches for 9.x will be provided for critical vulnerabilities only, on a best-effort basis, until August 2026.
+We recommend all users upgrade to the latest 11.x release. Security patches for 10.x will be provided for critical vulnerabilities only, on a best-effort basis, until November 2026.
 
 ---
 
@@ -44,18 +44,29 @@ We follow responsible disclosure practices. We will credit reporters in the rele
 
 ---
 
-## Security Features (v10.0.1)
+## Security Features (v11.0.0)
 
 ### Authentication & Authorization
 
 - **Bearer token auth on dashboard** — All mutating endpoints (`/api/steering`, `/api/approve`, SSE control) require `Authorization: Bearer <token>`. Token is sourced from `MINDFORGE_DASHBOARD_TOKEN` environment variable.
+- **Token expiration with refresh** — Dashboard tokens expire after 24 hours. Use `/api/v1/auth/refresh` to obtain a new token without re-authenticating.
+- **Dashboard rate limiting** — 100 requests per minute per IP address. Exceeding the limit returns 429 with `Retry-After` header.
+- **Session-scoped RBAC with TTL elevation** — Elevated permissions are session-scoped and auto-expire. No persistent privilege escalation.
 - **Browser daemon authentication** — The `/evaluate` endpoint requires auth before executing code in the Playwright context.
 - **ZTAI Trust Tiers** — 4-tier authorization model (Tier 0-3) controls which agents can perform which actions. Tier 3 (catastrophic-risk) operations require explicit human approval.
 
+### Cryptographic Security
+
+- **Ephemeral enclave keys** — All crypto keys generated via `crypto.randomBytes()` at runtime. No hardcoded secrets in source.
+- **Structured crypto boundaries** — Simulated (governance-enforcement) vs real (production-grade) cryptographic operations are clearly separated and labeled in code.
+- **GPG approval verification** — Optional GPG signature verification on governance approvals for high-trust environments.
+- **HMAC-signed temporal snapshots** — Temporal state captures are HMAC-signed to detect tampering during rollback operations.
+
 ### Audit & Integrity
 
 - **Merkle-chain audit log** — Every entry in `AUDIT.jsonl` includes a SHA-256 hash of the previous entry. Tampering with any historical entry breaks the chain, making modifications detectable.
 - **AuditWriter with buffered writes** — Atomic append operations prevent partial writes from corrupting the log.
+- **Log rotation with archival** — AUDIT.jsonl auto-archives beyond 5000 lines with gzip compression, preventing unbounded disk growth.
 - **npm provenance** — Published packages include SLSA Build Level 2 attestation via `--provenance`, proving the package was built from the stated source commit in CI.
 
 ### Input Validation & Injection Prevention
@@ -67,7 +78,7 @@ We follow responsible disclosure practices. We will credit reporters in the rele
 
 ### Governance & Policy
 
-- **Fail-closed ZK verification** — `verifyZKProof()` throws on invalid or missing proofs. The system denies by default.
+- **Structured ZK verification** — `verifyZKProof()` returns a structured result with `verified`, `reason`, and `timestamp` fields. The system denies by default when `verified` is false.
 - **Non-overridable parameters** — Security-critical MINDFORGE.md settings cannot be overridden by project-level or session-level configuration.
 - **CSP headers on dashboard** — Content Security Policy headers prevent XSS in the dashboard UI.
 - **Localhost-only binding** — The dashboard server binds to `127.0.0.1` only. It is not accessible from the network.
@@ -101,7 +112,8 @@ Before submitting code that touches security-sensitive paths:
 
 - **ZK-proofs are simulated** — The Dilithium-5 / ZK-proof layer uses cryptographic simulation, not hardware-backed TEEs. It provides logical governance enforcement, not hardware-grade isolation.
 - **Dashboard is localhost-only** — The dashboard is designed for local development. Do not expose it to the public internet, even behind a reverse proxy, without adding additional authentication.
-- **ZTAI keys are file-based** — Agent identity keys are stored on disk. In production deployments requiring hardware-bound keys, integrate with your organization's HSM or secure enclave.
+- **ZTAI keys are ephemeral** — Agent identity keys are generated per-session via `crypto.randomBytes()`. In production deployments requiring persistent hardware-bound keys, integrate with your organization's HSM or secure enclave.
+- **Rate limiting is per-process** — The 100 req/min limit is tracked in-memory. Restarting the dashboard resets counters. For distributed deployments, add an external rate limiter (e.g., nginx, Cloudflare).
 
 ---
 

package/bin/autonomous/audit-writer.js

@@ -6,11 +6,15 @@
 'use strict';
 
 const fs = require('fs');
+const path = require('path');
 const crypto = require('crypto');
+const { AuditRotator } = require('../utils/file-io');
 
 const FLUSH_INTERVAL_MS = 100;
 const FLUSH_THRESHOLD = 10;
 
+const rotator = new AuditRotator({ maxLines: 5000 });
+
 /**
  * Creates a buffered async audit writer.
  * @param {string} auditPath — Path to the AUDIT.jsonl file
@@ -70,6 +74,15 @@ function createAuditWriter(auditPath) {
 
     const payload = toWrite.map(e => JSON.stringify(e)).join('\n') + '\n';
     await fs.promises.appendFile(auditPath, payload);
+
+    try {
+      if (rotator.shouldRotate(auditPath)) {
+        const archiveDir = path.join(path.dirname(auditPath), '..', '.planning', 'audit-archive');
+        rotator.rotate(auditPath, archiveDir);
+      }
+    } catch (err) {
+      process.stderr.write(`[audit-writer] rotation warning: ${err.message}\n`);
+    }
   }
 
   /**

package/bin/autonomous/auto-runner.js

@@ -21,7 +21,7 @@ const ContextRefactorer = require('./context-refactorer');
 // Extracted modules (lightweight, always needed)
 const { createAuditWriter } = require('./audit-writer');
 const { createStateManager } = require('./state-manager');
-const { createWaveExecutor } = require('./wave-executor');
+const { createWaveExecutor, Semaphore } = require('./wave-executor');
 
 // ── Lazy-loaded heavy modules ────────────────────────────────────────────────
 // These are only required at the point of first use to reduce startup cost.
@@ -218,24 +218,44 @@ class AutoRunner {
     const wave = this.waves[this.currentWaveIndex];
     const waveNum = this.currentWaveIndex + 1;
     const pending = wave.tasks.filter(t => !this.completedTasks.has(t.id));
+    const maxConcurrency = this._getWaveConcurrency();
 
-    console.log(`\n⚡ Wave ${waveNum}/${this.waves.length}: ${pending.length} tasks`);
+    console.log(`\n⚡ Wave ${waveNum}/${this.waves.length}: ${pending.length} tasks (concurrency: ${maxConcurrency})`);
     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 });
-        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; }
-        if (strategy === 'ESCALATE') { this.writeAudit({ event: 'auto_mode_escalated', reason: `Task ${task.id} unrecoverable` }); this.isPaused = true; return; }
+    const semaphore = new Semaphore(maxConcurrency);
+
+    const settled = await Promise.allSettled(
+      pending.map(async (task) => {
+        await semaphore.acquire();
+        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 });
+          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);
+          return { taskId: task.id, status: 'fulfilled' };
+        } 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 });
+          throw { taskId: task.id, error: err, task };
+        } finally {
+          semaphore.release();
+        }
+      })
+    );
+
+    const failures = settled.filter(r => r.status === 'rejected');
+    if (failures.length > 0) {
+      for (const failure of failures) {
+        const { taskId, error, task } = failure.reason;
+        const strategy = repairOperator.determineRepairStrategy({ planId: task.plan || taskId, phase: this.phase, attemptNumber: 1, errorOutput: error.message, isTier3Change: false, isOnCriticalPath: (task.depends_on || []).length > 0 });
+        if (strategy === 'ESCALATE') {
+          this.writeAudit({ event: 'auto_mode_escalated', reason: `Task ${taskId} unrecoverable` });
+          this.isPaused = true;
+          return;
+        }
       }
     }
 
@@ -244,6 +264,19 @@ class AutoRunner {
     this.currentWaveIndex++;
   }
 
+  _getWaveConcurrency() {
+    try {
+      const configPath = path.join(process.cwd(), '.mindforge', 'config.json');
+      if (fs.existsSync(configPath)) {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        if (typeof config.wave_concurrency === 'number' && config.wave_concurrency > 0) {
+          return config.wave_concurrency;
+        }
+      }
+    } catch (e) { /* Fall through to default */ }
+    return 3;
+  }
+
   /**
    * Build wave groups from HANDOFF handoffs array.
    * Kept as instance method for backward compatibility with tests.
@@ -316,6 +349,15 @@ class AutoRunner {
       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); }
 
+    try {
+      _TemporalHub = lazyRequire(_TemporalHub, '../engine/temporal-hub');
+      const gcConfig = this._loadTemporalGcConfig();
+      const gcResult = await _TemporalHub.gc(gcConfig);
+      if (gcResult.deleted > 0) {
+        this.writeAudit({ event: 'temporal_gc_completed', deleted: gcResult.deleted, remaining: gcResult.remaining });
+      }
+    } catch (e) { /* GC failure is non-critical */ }
+
     this.writeAudit({ event: 'auto_mode_completed', timestamp: new Date().toISOString() });
     await this.auditWriter.close();
   }
@@ -334,7 +376,7 @@ class AutoRunner {
     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 = lazyRequire(_TemporalHub, '../engine/temporal-hub');
-      _TemporalHub.captureState(event.id, { agent: event.agent || 'auto-runner', event: event.event, phase: this.phase });
+      _TemporalHub.captureState(event.id, { agent: event.agent || 'auto-runner', event: event.event, phase: this.phase }).catch(() => {});
     }
 
     const result = this.monitor.analyze(event);
@@ -444,6 +486,22 @@ class AutoRunner {
     const lines = buf.toString('utf8').trim().split('\n');
     return lines.slice(-count).map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
   }
+
+  _loadTemporalGcConfig() {
+    try {
+      const configPath = path.join(process.cwd(), '.mindforge', 'config.json');
+      if (fs.existsSync(configPath)) {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        if (config.temporal) {
+          return {
+            maxSnapshots: config.temporal.max_snapshots || 50,
+            maxAgeDays: config.temporal.max_age_days || 7
+          };
+        }
+      }
+    } catch (e) { /* Fall through to defaults */ }
+    return { maxSnapshots: 50, maxAgeDays: 7 };
+  }
 }
 
 module.exports = AutoRunner;

package/bin/autonomous/context-refactorer.js

@@ -14,18 +14,15 @@ class ContextRefactorer {
     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 windowSize = this._getAdaptiveWindow(events);
+    this.history = events.slice(-windowSize);
 
-    const implementationEvents = this.history.filter(h => 
-      h.tool === 'run_command' || 
-      h.tool === 'replace_file_content' || 
+    if (this.history.length < 5) return { density: 1.0, shouldRefactor: false, windowSize };
+
+    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'
     );
@@ -35,10 +32,28 @@ class ContextRefactorer {
 
     return {
       density: parseFloat(density.toFixed(2)),
-      shouldRefactor: density < this.threshold
+      shouldRefactor: density < this.threshold,
+      windowSize
     };
   }
 
+  _getAdaptiveWindow(events) {
+    const recent = events.slice(-10);
+    if (recent.length === 0) return 20;
+
+    const implEvents = recent.filter(e =>
+      e.event === 'run_command' ||
+      e.event?.includes('replace_file') ||
+      e.event === 'task_completed'
+    ).length;
+
+    const velocity = implEvents / recent.length;
+
+    if (velocity > 0.6) return 10;
+    if (velocity < 0.3) return 30;
+    return 20;
+  }
+
   /**
    * Generates a "Context Refactor" recommendation.
    */