mindforge-cc 1.0.5 → 2.0.0-alpha.4

package/MINDFORGE.md

@@ -22,9 +22,9 @@ If a configured model is unavailable, fallback to `inherit` and warn.
 
 ## Project identity
 NAME=MindForge
-VERSION=1.0.0
-DESCRIPTION=Enterprise agentic framework with intelligence and observability layer
-MINDFORGE_VERSION_REQUIRED=1.0.0
+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
@@ -33,6 +33,15 @@ 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
@@ -59,6 +68,20 @@ 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
+
 ## Project-specific agent instructions
 ADDITIONAL_AGENT_INSTRUCTIONS="""
 - Check packages/shared before creating utilities.

package/README.md

@@ -1,4 +1,4 @@
-# MindForge — Enterprise Agentic Framework (v1.0.0)
+# MindForge — Enterprise Agentic Framework (v2.0.0-alpha.4)
 
 MindForge turns Claude Code and Antigravity into production-grade engineering
 partners with governance, observability, and a disciplined workflow engine.
@@ -18,6 +18,10 @@ Decisions get forgotten. MindForge fixes that with:
 - **Role personas** — specialised agent modes for each task type
 - **Skills** — just-in-time domain knowledge loaded on demand
 - **Wave execution** — parallelism with dependency safety
+- **Autonomous Engine** — walk-away execution with steerability (v2)
+- **Browser Runtime** — headful/headless visual QA and sessions (v2)
+- **Multi-Model Intelligence** — dynamic routing, adversarial reviews, and deep research (v2)
+- **Persistent Knowledge Graph** — long-term memory across all engineering sessions (v2)
 - **Quality gates** — compliance and security are non-bypassable
 - **Audit trail** — append-only history of every action
 
@@ -61,18 +65,19 @@ npx mindforge-cc@latest --all --global
 
 ## Verify
 Open Claude Code or Antigravity in your project directory and run:
-```
+```bash
 /mindforge:health
 ```
+
 If issues are found, run:
-```
+```bash
 /mindforge:health --repair
 ```
 
 ---
 
 ## Quick start (new project)
-```
+```bash
 /mindforge:init-project
 /mindforge:plan-phase 1
 /mindforge:execute-phase 1
@@ -81,7 +86,7 @@ If issues are found, run:
 ```
 
 ## Quick start (existing codebase)
-```
+```bash
 /mindforge:map-codebase
 /mindforge:plan-phase 1
 ```
@@ -89,7 +94,7 @@ If issues are found, run:
 ---
 
 ## Core workflow
-```
+```bash
 / mindforge:init-project
     → Requirements interview
     → Creates PROJECT.md, REQUIREMENTS.md, STATE.md
@@ -113,12 +118,38 @@ If issues are found, run:
     → Changelog generation
     → Final quality gates
     → PR creation
+
+/ mindforge:auto --phase 1
+    → Walk-away autonomous execution (v2)
+    → Intelligent stuck detection and node repair
+    → External steering via steering-queue
+
+/ mindforge:qa
+    → Systematic visual verification of UI changes (v2)
+    → Automated regression test generation
+    → Persistent browser sessions and daemon
+
+/ mindforge:cross-review
+    → Adversarial multi-model code review and synthesis (v2)
+    → Consensus detection and severity normalization
+
+/ mindforge:research
+    → Deep research using Gemini 1.5 Pro 1M context (v2)
+    → Codebase-wide context packaging and SSRF protection
+
+/ mindforge:costs
+    → Real-time token usage and cost profiling (v2)
+    → Daily budget tracking across all providers
+
+/ mindforge:remember
+    → Manual knowledge management and search (v2)
+    → Persistent knowledge graph retrieval and promotion
 ```
 
 ---
 
 ## Updates and migrations
-```
+```bash
 /mindforge:update
 /mindforge:update --apply
 /mindforge:migrate --from v0.6.0 --to v1.0.0
@@ -169,17 +200,22 @@ See `.mindforge/production/token-optimiser.md`.
 
 ---
 
-## What ships in v1.0.0
-- 36 commands across 7 workflow categories
-- 10 core skill packs with a three-tier registry (Core/Org/Project)
-- 8 specialised agent personas
-- Wave-based execution with dependency graph and compaction
-- Enterprise integrations: Jira, Confluence, Slack, GitHub, GitLab
-- Three-tier governance with 5 non-bypassable compliance gates
-- Intelligence layer: health engine, difficulty scoring, anti-pattern detection
-- Public skills registry and plugin system
-- @mindforge/sdk with event stream and command builders
-- 15 test suites, production checklist, and threat model
+## What ships in v2.0.0-alpha.4
+- **Persistent Knowledge Graph**: `/mindforge:remember` and long-term memory engine.
+- **Multi-Model Intelligence Layer**: `/mindforge:cross-review`, `/mindforge:research`, and `/mindforge:costs`.
+- **Visual QA Engine**: `/mindforge:qa` and automated regression tests.
+- **Persistent Browser Runtime**: `/mindforge:browse` and Playwright integration.
+- **Autonomous Execution Engine**: `/mindforge:auto` and `/mindforge:steer`.
+- 48+ commands across 10 workflow categories.
+- 12 core skill packs with a three-tier registry.
+- 8 specialised agent personas.
+- Wave-based execution with dependency graph and compaction.
+- Enterprise integrations: Jira, Confluence, Slack, GitHub, GitLab.
+- Three-tier governance with 6 non-bypassable compliance gates.
+- Intelligence layer: health engine, difficulty scoring, anti-pattern detection.
+- Public skills registry and plugin system.
+- @mindforge/sdk with event stream and command builders.
+- 20 test suites, production checklist, and 32 ADRs.
 
 ---
 

package/bin/autonomous/auto-runner.js

@@ -0,0 +1,95 @@
+/**
+ * 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');
+
+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;
+  }
+
+  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;
+      await this.executeWave();
+    }
+
+    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() {
+    // Parallel task execution logic...
+  }
+
+  async pause() {
+    this.isPaused = true;
+    this.updateState({ status: 'paused' });
+    this.writeAudit({ event: 'auto_mode_paused', timestamp: new Date().toISOString() });
+  }
+
+  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);
+    this.writeAudit({ event: 'auto_mode_completed', timestamp: new Date().toISOString() });
+  }
+
+  writeAudit(event) {
+    if (!event.timestamp) event.timestamp = new Date().toISOString();
+    fs.appendFileSync(this.auditPath, JSON.stringify(event) + '\n');
+    const result = this.monitor.analyze(event);
+    if (result) this.handleStuck(result);
+  }
+
+  handleStuck(result) {
+    console.error(`🛑 STUCK PATTERN DETECTED: ${result.pattern} - ${result.message}`);
+    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));
+  }
+}
+
+module.exports = AutoRunner;

package/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/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 };

package/bin/autonomous/repair-operator.js

@@ -0,0 +1,213 @@
+/**
+ * MindForge — Node Repair Operator
+ * Implements RETRY → DECOMPOSE → PRUNE → ESCALATE decision logic.
+ */
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+/**
+ * Determine the repair strategy for a failed task.
+ * @param {object} context - Task context
+ * @returns {'RETRY'|'DECOMPOSE'|'PRUNE'|'ESCALATE'}
+ */
+function determineRepairStrategy(context) {
+  const {
+    planId,
+    phase,
+    attemptNumber,     // 1 = first failure, 2 = retry also failed
+    errorOutput,
+    isTier3Change,
+    isOnCriticalPath,  // other plans have this plan as a dependency
+    planFilePath,
+    repairBudget = 2,
+  } = context;
+
+  // Tier 3 changes ALWAYS escalate — never auto-approve auth/payment/PII
+  if (isTier3Change) {
+    return 'ESCALATE';
+  }
+
+  // First failure — always try RETRY first
+  if (attemptNumber === 1) {
+    return 'RETRY';
+  }
+
+  // Retry also failed — try DECOMPOSE if the plan is decomposable
+  if (attemptNumber === 2 && isPlanDecomposable(planFilePath)) {
+    return 'DECOMPOSE';
+  }
+
+  // Cannot DECOMPOSE (or decompose also failed) — try PRUNE if not critical path
+  if (!isOnCriticalPath) {
+    return 'PRUNE';
+  }
+
+  // On critical path and all repair strategies exhausted — must ESCALATE
+  return 'ESCALATE';
+}
+
+/**
+ * Check if a plan can be split into independent sub-plans.
+ */
+function isPlanDecomposable(planFilePath) {
+  if (!fs.existsSync(planFilePath)) return false;
+  const content = fs.readFileSync(planFilePath, 'utf8');
+
+  // Count distinct file domains
+  const filesMatch = content.match(/<files>([\s\S]*?)<\/files>/);
+  if (!filesMatch) return false;
+  const files = filesMatch[1].trim().split('\n').filter(Boolean);
+
+  // Decomposable if:
+  // 1. More than 2 files (enough to split)
+  // 2. Files span different directories (different concerns)
+  if (files.length <= 1) return false;
+  const dirs = new Set(files.map(f => f.trim().split('/').slice(0, 2).join('/')));
+  return dirs.size > 1;
+}
+
+/**
+ * Generate RETRY context injection — adds error details for the retry subagent.
+ */
+function buildRetryContext(errorOutput, attemptNumber) {
+  const normalized = errorOutput
+    .split('\n')
+    .filter(l => /error|FAIL|error/i.test(l))
+    .slice(0, 5)
+    .join('\n');
+
+  return `
+[RETRY CONTEXT — attempt ${attemptNumber} of 2]
+Previous attempt failed with:
+${normalized}
+
+Instructions:
+- Do NOT repeat the same approach that caused this error
+- Fix the specific error above before implementing new functionality
+- If the error is an import/module error: verify the package is installed
+- If the error is a type error: check the exact type definitions
+- If the error is a test failure: read the test assertion carefully
+`.trim();
+}
+
+/**
+ * Build decomposed sub-plans from a failed plan.
+ * Returns two PLAN file contents as strings.
+ */
+function buildDecomposedPlans(planContent, originalPlanId, phase) {
+  const xmlMatch = planContent.match(/<task[^>]*>([\s\S]*?)<\/task>/);
+  if (!xmlMatch) return null;
+
+  const name       = (planContent.match(/<n>(.*?)<\/n>/) || [])[1] || 'Task';
+  const action     = (planContent.match(/<action>([\s\S]*?)<\/action>/) || [])[1] || '';
+  const filesMatch = planContent.match(/<files>([\s\S]*?)<\/files>/);
+  const files      = filesMatch ? filesMatch[1].trim().split('\n').filter(Boolean) : [];
+  const persona    = (planContent.match(/<persona>(.*?)<\/persona>/) || [])[1] || 'developer';
+
+  const mid      = Math.ceil(files.length / 2);
+  const filesA   = files.slice(0, mid);
+  const filesB   = files.slice(mid);
+  const idA      = `${originalPlanId}a`;
+  const idB      = `${originalPlanId}b`;
+
+  const planA = `<task type="auto">
+  <n>${name} — Part A (Foundation)</n>
+  <persona>${persona}</persona>
+  <phase>${phase}</phase>
+  <plan>${idA}</plan>
+  <decomposed_from>${originalPlanId}</decomposed_from>
+  <dependencies>${getPlanDependencies(planContent)}</dependencies>
+  <files>
+${filesA.map(f => `    ${f.trim()}`).join('\n')}
+  </files>
+  <action>
+${splitAction(action, 'first_half')}
+  </action>
+  <verify>Run the tests for the files modified in this sub-task only</verify>
+  <done>Part A files exist, compile cleanly, and their specific tests pass</done>
+</task>`;
+
+  const planB = `<task type="auto">
+  <n>${name} — Part B (Integration)</n>
+  <persona>${persona}</persona>
+  <phase>${phase}</phase>
+  <plan>${idB}</plan>
+  <decomposed_from>${originalPlanId}</decomposed_from>
+  <dependencies>${idA}</dependencies>
+  <files>
+${filesB.map(f => `    ${f.trim()}`).join('\n')}
+  </files>
+  <action>
+${splitAction(action, 'second_half')}
+  </action>
+  <verify>Run the full test suite for the entire ${name} feature</verify>
+  <done>All ${name} functionality working end-to-end</done>
+</task>`;
+
+  return { planA, planB, idA, idB };
+}
+
+/**
+ * Fix the dependency chain after decomposing a plan.
+ * Any plan that depended on the original plan now depends on the second sub-plan.
+ */
+function fixDependencyChain(phaseDir, originalPlanId, newDependentPlanId, phase) {
+  const planFiles = fs.readdirSync(phaseDir)
+    .filter(f => f.match(new RegExp(`^PLAN-${phase}-\\d`)) && f.endsWith('.md'));
+
+  let fixed = 0;
+  for (const planFile of planFiles) {
+    const filePath = path.join(phaseDir, planFile);
+    const content  = fs.readFileSync(filePath, 'utf8');
+
+    // Check if this plan depends on the original decomposed plan
+    const depPattern = new RegExp(`<dependencies>([^<]*\\b${originalPlanId}\\b[^<]*)</dependencies>`);
+    if (depPattern.test(content)) {
+      const updated = content.replace(depPattern, (match, deps) => {
+        const newDeps = deps.replace(new RegExp(`\\b${originalPlanId}\\b`, 'g'), newDependentPlanId);
+        return `<dependencies>${newDeps}</dependencies>`;
+      });
+      fs.writeFileSync(filePath, updated);
+      fixed++;
+    }
+  }
+  return fixed;
+}
+
+function getPlanDependencies(planContent) {
+  return (planContent.match(/<dependencies>(.*?)<\/dependencies>/) || [])[1] || 'none';
+}
+
+function splitAction(action, half) {
+  // Try period-delimited split first
+  const periodSplit = action.split(/\.\s+/);
+  if (periodSplit.length > 1) {
+    const mid = Math.ceil(periodSplit.length / 2);
+    return half === 'first_half'
+      ? periodSplit.slice(0, mid).join('. ').trim()
+      : periodSplit.slice(mid).join('. ').trim();
+  }
+
+  // Try newline-bullet split
+  const bulletSplit = action.split(/\n-\s+/);
+  if (bulletSplit.length > 1) {
+    const mid = Math.ceil(bulletSplit.length / 2);
+    return half === 'first_half'
+      ? bulletSplit.slice(0, mid).join('\n- ').trim()
+      : bulletSplit.slice(mid).join('\n- ').trim();
+  }
+
+  // Fallback: prefix the whole action with a half indicator
+  const prefix = half === 'first_half' ? 'First half of: ' : 'Second half of: ';
+  return prefix + action.trim().slice(0, Math.ceil(action.length / 2));
+}
+
+module.exports = {
+  determineRepairStrategy,
+  isPlanDecomposable,
+  buildRetryContext,
+  buildDecomposedPlans,
+  fixDependencyChain,
+};

package/bin/autonomous/steer.js

@@ -0,0 +1,71 @@
+/**
+ * MindForge — Steering Manager
+ * Manages mid-execution guidance via steering-queue.jsonl.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const QUEUE_PATH = path.join(process.cwd(), '.planning/steering-queue.jsonl');
+
+/**
+ * Add guidance to the queue.
+ */
+function pushGuidance(instruction, scope = 'global', taskId = null) {
+  const item = {
+    id: `steer-${Date.now()}`,
+    timestamp: new Date().toISOString(),
+    instruction,
+    scope,
+    taskId
+  };
+  fs.appendFileSync(QUEUE_PATH, JSON.stringify(item) + '\n');
+  return item.id;
+}
+
+/**
+ * Get and remove all pending guidance for the current context.
+ */
+function popGuidance(taskId = null) {
+  if (!fs.existsSync(QUEUE_PATH)) return [];
+
+  const lines = fs.readFileSync(QUEUE_PATH, 'utf8').split('\n').filter(Boolean);
+  const relevant = [];
+  const remaining = [];
+
+  for (const line of lines) {
+    const item = JSON.parse(line);
+    if (item.scope === 'global' || item.taskId === taskId) {
+      relevant.push(item);
+    } else {
+      remaining.push(item);
+    }
+  }
+
+  // Rewrite remaining
+  fs.writeFileSync(QUEUE_PATH, remaining.map(JSON.stringify).join('\n') + (remaining.length ? '\n' : ''));
+  return relevant;
+}
+
+/**
+ * Inject steering guidance into a PLAN file content.
+ */
+function injectSteering(planContent, guidanceItems) {
+  if (!guidanceItems || guidanceItems.length === 0) return planContent;
+
+  const guidanceText = guidanceItems
+    .map(g => `[STEERING GUIDANCE — DO NOT IGNORE] ${g.instruction}`)
+    .join('\n');
+
+  // Hardened injection: inject at beginning of <action> to ensure visibility
+  return planContent.replace(/<action>([\s\S]*?)<\/action>/, (match, action) => {
+    return `<action>\n${guidanceText}\n\nOriginal plan instructions:\n${action}\n</action>`;
+  });
+}
+
+module.exports = {
+  pushGuidance,
+  popGuidance,
+  injectSteering
+};