mindforge-cc 8.1.0 → 8.2.0

package/.mindforge/mirrors/mirror-sre-776a1cf9/tests/model-routing.test.js

@@ -0,0 +1,111 @@
+/**
+ * MindForge v2 — Multi-Model Layer Tests
+ */
+'use strict';
+
+const assert = require('assert');
+const Router = require('../bin/models/model-router');
+const CostTracker = require('../bin/models/cost-tracker');
+const FindingSynthesizer = require('../bin/review/finding-synthesizer');
+
+async function testRouter() {
+  console.log('Testing Model Router...');
+  
+  // Test Persona Mapping
+  const researchModel = Router.route('research-agent', 1).model;
+  assert.strictEqual(researchModel, 'gemini-1.5-pro');
+
+  // Test Tier Override (Tier 3 -> Security Model)
+  const securityModel = Router.route('developer', 3).model;
+  assert.strictEqual(securityModel, 'claude-3-opus-20240229');
+
+  // Test Budget Bias (Low difficulty/tier -> Cheap model)
+  const cheapModel = Router.route('developer', 1).model;
+  assert.strictEqual(cheapModel, 'claude-3-5-haiku-20241022');
+
+  console.log('✅ Router tests passed.');
+}
+
+async function testCostTracker() {
+  console.log('Testing Cost Tracker...');
+  
+  const initialSpend = await CostTracker.getTodaySpend();
+  
+  // Record a dummy call
+  await CostTracker.record({
+    model: 'gpt-4o',
+    input_tokens: 1000,
+    output_tokens: 500,
+    cost_usd: 0.0125
+  });
+
+  const newSpend = await CostTracker.getTodaySpend();
+  assert.ok(newSpend > initialSpend);
+
+  // Test Preflight (Budget enforcement)
+  try {
+    const canCall = await CostTracker.preflight(0.01);
+    assert.strictEqual(typeof canCall, 'undefined'); // preflight returns undefined or throws
+  } catch (e) {
+    if (e.code !== 'COST_LIMIT_REACHED') throw e;
+  }
+
+  console.log('✅ Cost Tracker tests passed.');
+}
+
+function testSynthesizer() {
+  console.log('Testing Finding Synthesizer...');
+
+  const review1 = {
+    model: 'claude-3-5-sonnet',
+    content: '**[HIGH]** `index.js:10` — Infinite loop detected.\n### Verdict: REQUEST_CHANGES'
+  };
+  const review2 = {
+    model: 'gpt-4o',
+    content: '**[CRITICAL]** `index.js:12` — Potential crash in error handler.\n### Verdict: REQUEST_CHANGES'
+  };
+
+  const synthesis = FindingSynthesizer.synthesizeFindings([review1, review2]);
+  
+  // Location normalization should group index.js:10 and index.js:12 (same 20-line band)
+  assert.strictEqual(synthesis.consensus.length, 1);
+  assert.strictEqual(synthesis.consensus[0].severity, 'CRITICAL');
+  assert.strictEqual(synthesis.overall_verdict, 'REQUEST_CHANGES');
+
+  console.log('✅ Synthesizer tests passed.');
+}
+
+async function testGeminiAuth() {
+  console.log('Testing Gemini Header Auth...');
+  
+  // This is a unit test of the provider's header generation logic
+  // (We don't make a real call here to avoid using keys)
+  const options = {
+    hostname: 'generativelanguage.googleapis.com',
+    path: '/v1beta/models/gemini-1.5-pro:generateContent',
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'x-goog-api-key': 'test-key'
+    }
+  };
+  
+  assert.strictEqual(options.headers['x-goog-api-key'], 'test-key');
+  console.log('✅ Gemini Auth verification passed.');
+}
+
+async function runAll() {
+  try {
+    await testRouter();
+    await testCostTracker();
+    testSynthesizer();
+    await testGeminiAuth();
+    console.log('\n✨ ALL MULTI-MODEL TESTS PASSED ✨');
+  } catch (e) {
+    console.error('\n❌ TEST FAILURE:');
+    console.error(e);
+    process.exit(1);
+  }
+}
+
+runAll();

package/.mindforge/mirrors/mirror-sre-776a1cf9/tests/nexus-tracing.test.js

@@ -0,0 +1,49 @@
+const fs = require('fs');
+const path = require('path');
+const NexusTracer = require('../.mindforge/engine/nexus-tracer');
+
+describe('Nexus Tracer & ART Protocol', () => {
+  const auditPath = path.join(__dirname, '../.planning/AUDIT.jsonl');
+
+  beforeEach(() => {
+    // Clear audit log before tests
+    if (fs.existsSync(auditPath)) {
+      fs.truncateSync(auditPath, 0);
+    }
+  });
+
+  test('should initialize a valid trace and spans', async () => {
+    const span = await NexusTracer.startSpan('test_wave_01');
+    expect(span.trace_id).toBeDefined();
+    expect(span.id).toBeDefined(); // Use span.id instead of span_id
+    expect(span.name).toBe('test_wave_01');
+  });
+
+  test('should support hierarchical spans', async () => {
+    const parentId = await NexusTracer.startSpan('parent');
+    const childId = await NexusTracer.startSpan('child', {}, parentId);
+    
+    const child = NexusTracer.activeSpans.get(childId);
+    expect(child.trace_id).toBe(NexusTracer.currentTraceId);
+    expect(child.parent_id).toBe(parentId);
+  });
+
+  test('should record reasoning trace to AUDIT.jsonl', async () => {
+    const spanId = await NexusTracer.startSpan('reasoning_task');
+    await NexusTracer.recordReasoning(spanId, 'test-agent', 'Considering memory safety in Rust vs C++');
+    
+    const logs = fs.readFileSync(auditPath, 'utf8').split('\n').filter(Boolean);
+    const lastEntry = JSON.parse(logs[logs.length - 1]);
+    
+    expect(lastEntry.event).toBe('reasoning_trace');
+    expect(lastEntry.thought).toContain('memory safety');
+    expect(lastEntry.trace_id).toBe(NexusTracer.currentTraceId);
+  });
+
+  test('should close spans and update state', async () => {
+    const spanId = await NexusTracer.startSpan('closing_task');
+    await NexusTracer.endSpan(spanId);
+    
+    expect(NexusTracer.activeSpans.has(spanId)).toBe(false);
+  });
+});

package/.mindforge/mirrors/mirror-sre-776a1cf9/tests/production.test.js

@@ -0,0 +1,416 @@
+/**
+ * MindForge Day 7 — Production Readiness Tests
+ * Verifies the installer, updater, migration engine, plugin system,
+ * token optimiser, and all 36 commands exist.
+ *
+ * Run: node tests/production.test.js
+ */
+'use strict';
+
+const fs   = require('fs');
+const assert = require('assert');
+let passed = 0, failed = 0;
+
+function test(name, fn) {
+  try { fn(); console.log(`  ✅  ${name}`); passed++; }
+  catch(e) { console.error(`  ❌  ${name}\n      ${e.message}`); failed++; }
+}
+
+const read   = p  => fs.existsSync(p) ? fs.readFileSync(p, 'utf8') : '';
+const exists = p  => fs.existsSync(p);
+
+// ── Installer completeness ─────────────────────────────────────────────────────
+console.log('\nMindForge Day 7 — Production Readiness Tests\n');
+console.log('Installer:');
+
+test('bin/install.js exists with shebang', () => {
+  const c = read('bin/install.js');
+  assert.ok(c.includes('#!/usr/bin/env node'), 'Missing shebang');
+  assert.ok(c.length > 500, 'install.js seems too short');
+});
+
+test('bin/installer-core.js exists and exports run()', () => {
+  const c = read('bin/installer-core.js');
+  assert.ok(c.includes('module.exports'), 'Missing module.exports');
+  assert.ok(c.includes('async function run') || c.includes('function run'), 'Missing run function');
+});
+
+test('installer handles --version flag correctly', () => {
+  const c = read('bin/install.js');
+  assert.ok(c.includes('\'--version\'') || c.includes('"--version"'), 'Missing --version');
+  assert.ok(c.includes('process.exit(0)'), 'Should exit 0 for --version');
+});
+
+test('installer has Node.js version gate (≥ 18)', () => {
+  const combined = read('bin/install.js') + read('bin/installer-core.js');
+  assert.ok(combined.includes('18'), 'Should check for Node.js 18');
+  assert.ok(combined.includes('process.exit(1)') || combined.includes('exit(1)'), 'Should exit 1 for old node');
+});
+
+test('installer has CI mode detection', () => {
+  const c = read('bin/install.js');
+  assert.ok(c.includes('process.env.CI'), 'Should detect CI environment');
+  assert.ok(c.includes('IS_NON_INTERACTIVE'), 'Should have non-interactive flag');
+});
+
+test('installer backs up existing CLAUDE.md', () => {
+  const c = read('bin/installer-core.js');
+  assert.ok(c.includes('backup') || c.includes('.backup-'), 'Should back up CLAUDE.md');
+});
+
+test('installer has self-install detection', () => {
+  const c = read('bin/installer-core.js');
+  assert.ok(
+    c.includes('isSelfInstall') || c.includes('\'mindforge-cc\''),
+    'Should detect self-install scenario'
+  );
+});
+
+test('installer excludes sensitive files (*.env, *.key, *.pem)', () => {
+  const c = read('bin/installer-core.js');
+  assert.ok(
+    c.includes('.env') || c.includes('SENSITIVE_EXCLUDE') || c.includes('.key'),
+    'Should have sensitive file exclusion list'
+  );
+});
+
+test('installer verifies install after completing', () => {
+  const c = read('bin/installer-core.js');
+  assert.ok(
+    c.includes('verifyInstall') || c.includes('verification'),
+    'Should verify install after completing'
+  );
+});
+
+// ── Self-update system ─────────────────────────────────────────────────────────
+console.log('\nSelf-update system:');
+
+['version-comparator.js', 'changelog-fetcher.js', 'self-update.js'].forEach(f => {
+  test(`bin/updater/${f} exists`, () => {
+    assert.ok(exists(`bin/updater/${f}`), `Missing: bin/updater/${f}`);
+  });
+});
+
+test('compareSemver: 1.0.0 > 0.6.0', () => {
+  const { compareSemver } = require('../bin/updater/version-comparator');
+  assert.ok(compareSemver('1.0.0', '0.6.0') > 0);
+});
+
+test('compareSemver: 0.6.0 < 1.0.0', () => {
+  const { compareSemver } = require('../bin/updater/version-comparator');
+  assert.ok(compareSemver('0.6.0', '1.0.0') < 0);
+});
+
+test('compareSemver: 1.0.0 == 1.0.0', () => {
+  const { compareSemver } = require('../bin/updater/version-comparator');
+  assert.strictEqual(compareSemver('1.0.0', '1.0.0'), 0);
+});
+
+test('compareSemver handles v prefix', () => {
+  const { compareSemver } = require('../bin/updater/version-comparator');
+  assert.ok(compareSemver('v1.0.0', 'v0.6.0') > 0);
+});
+
+test('upgradeType: 0.6.0 → 1.0.0 is major', () => {
+  const { upgradeType } = require('../bin/updater/version-comparator');
+  assert.strictEqual(upgradeType('0.6.0', '1.0.0'), 'major');
+});
+
+test('upgradeType: 1.0.0 → 1.1.0 is minor', () => {
+  const { upgradeType } = require('../bin/updater/version-comparator');
+  assert.strictEqual(upgradeType('1.0.0', '1.1.0'), 'minor');
+});
+
+test('upgradeType: 1.0.0 → 1.0.1 is patch', () => {
+  const { upgradeType } = require('../bin/updater/version-comparator');
+  assert.strictEqual(upgradeType('1.0.0', '1.0.1'), 'patch');
+});
+
+test('upgradeType: 1.0.0 → 1.0.0 is none', () => {
+  const { upgradeType } = require('../bin/updater/version-comparator');
+  assert.strictEqual(upgradeType('1.0.0', '1.0.0'), 'none');
+});
+
+test('self-update has scope detection', () => {
+  const c = read('bin/updater/self-update.js');
+  assert.ok(c.includes('detectInstallScope'), 'Should have detectInstallScope()');
+});
+
+test('self-update reads schema_version before applying update', () => {
+  const c = read('bin/updater/self-update.js');
+  assert.ok(
+    c.includes('readHandoffSchemaVersion') || c.includes('schema_version'),
+    'Should read schema_version from HANDOFF before updating'
+  );
+});
+
+// ── Migration engine ────────────────────────────────────────────────────────────
+console.log('\nMigration engine:');
+
+['migrate.js', 'schema-versions.js', '0.1.0-to-0.5.0.js', '0.5.0-to-0.6.0.js', '0.6.0-to-1.0.0.js'].forEach(f => {
+  test(`bin/migrations/${f} exists`, () => {
+    assert.ok(exists(`bin/migrations/${f}`), `Missing: ${f}`);
+  });
+});
+
+test('migrate.js creates backup before migrating', () => {
+  const c = read('bin/migrations/migrate.js');
+  assert.ok(c.includes('backup') || c.includes('Backup'), 'Should create backup');
+});
+
+test('migrate.js aborts if backup fails', () => {
+  const c = read('bin/migrations/migrate.js');
+  assert.ok(
+    c.includes('backupErr') || c.includes('Migration aborted'),
+    'Should abort if backup creation fails'
+  );
+});
+
+test('migrate.js restores from backup on migration failure', () => {
+  const c = read('bin/migrations/migrate.js');
+  assert.ok(
+    c.includes('Restoring') || c.includes('restoreFromBackup') || c.includes('restore'),
+    'Should restore from backup on failure'
+  );
+});
+
+test('0.6.0-to-1.0.0 migration adds plugin_api_version', () => {
+  const c = read('bin/migrations/0.6.0-to-1.0.0.js');
+  assert.ok(c.includes('plugin_api_version'), 'Should add plugin_api_version field');
+});
+
+test('0.6.0-to-1.0.0 migration backfills session_id in AUDIT.jsonl', () => {
+  const c = read('bin/migrations/0.6.0-to-1.0.0.js');
+  assert.ok(c.includes('session_id'), 'Should backfill session_id');
+});
+
+test('0.6.0-to-1.0.0 migration converts VERIFY_PASS_RATE_WARNING_THRESHOLD', () => {
+  const c = read('bin/migrations/0.6.0-to-1.0.0.js');
+  assert.ok(
+    c.includes('VERIFY_PASS_RATE') || c.includes('val / 100'),
+    'Should convert percentage to decimal'
+  );
+});
+
+test('migration preserves invalid AUDIT.jsonl lines (no crash)', () => {
+  const c = read('bin/migrations/0.6.0-to-1.0.0.js');
+  assert.ok(c.includes('catch') || c.includes('try'), 'Should handle parse errors gracefully');
+});
+
+// ── Plugin system ────────────────────────────────────────────────────────────────
+console.log('\nPlugin system:');
+
+['plugin-schema.md', 'plugin-loader.md', 'PLUGINS-MANIFEST.md'].forEach(f => {
+  test(`.mindforge/plugins/${f} exists`, () => {
+    assert.ok(exists(`.mindforge/plugins/${f}`));
+  });
+});
+
+test('plugin schema defines permission model', () => {
+  const c = read('.mindforge/plugins/plugin-schema.md');
+  assert.ok(c.includes('permissions'), 'Should define permissions');
+  assert.ok(c.includes('write_state'), 'Should include write_state permission');
+  assert.ok(c.includes('network_access'), 'Should include network_access permission');
+});
+
+test('plugin loader has injection guard step', () => {
+  const c = read('.mindforge/plugins/plugin-loader.md');
+  assert.ok(c.includes('injection guard') || c.includes('Injection'), 'Should run injection guard');
+});
+
+test('plugin loader documents advisory permission model', () => {
+  const c = read('.mindforge/plugins/plugin-loader.md');
+  assert.ok(
+    c.includes('advisory') || c.includes('not OS-enforced') || c.includes('not enforced'),
+    'Should explain that permissions are advisory'
+  );
+});
+
+test('plugin schema lists all 36 reserved command names', () => {
+  const c = read('.mindforge/plugins/plugin-schema.md');
+  assert.ok(
+    c.includes('Reserved command names') || c.includes('reserved'),
+    'Should list reserved command names'
+  );
+  // Check a few specific reserved names are mentioned
+  assert.ok(c.includes('health'), 'Should list health as reserved');
+  assert.ok(c.includes('security-scan'), 'Should list security-scan as reserved');
+});
+
+// ── Token optimiser ─────────────────────────────────────────────────────────────
+console.log('\nToken optimiser:');
+
+test('token-optimiser.md exists', () => {
+  assert.ok(exists('.mindforge/production/token-optimiser.md'));
+});
+
+test('token optimiser defines efficiency formula', () => {
+  const c = read('.mindforge/production/token-optimiser.md');
+  assert.ok(c.includes('token_efficiency') || c.includes('efficiency'), 'Should define efficiency');
+  assert.ok(c.includes('useful_output') || c.includes('output_tokens'), 'Should define useful output');
+});
+
+test('token optimiser has lean plan strategy', () => {
+  const c = read('.mindforge/production/token-optimiser.md');
+  assert.ok(c.includes('Strategy 1') || c.includes('Lean'), 'Should have lean plan strategy');
+});
+
+// ── Production checklist ────────────────────────────────────────────────────────
+console.log('\nProduction checklist:');
+
+test('production-checklist.md has exactly 50 checkbox items', () => {
+  const c = read('.mindforge/production/production-checklist.md');
+  const boxes = (c.match(/- \[ \]/g) || []).length;
+  assert.ok(boxes >= 50, `Expected >= 50 items, found ${boxes}`);
+});
+
+// ── Documentation completeness ──────────────────────────────────────────────────
+console.log('\nDocumentation:');
+
+const DOC_FILES = [
+  'docs/reference/commands.md',
+  'docs/security/SECURITY.md',
+  'docs/security/threat-model.md',
+  'docs/architecture/decision-records-index.md',
+  'docs/contributing/CONTRIBUTING.md',
+];
+DOC_FILES.forEach(f => test(`${f} exists`, () => assert.ok(exists(f), `Missing: ${f}`)));
+
+test('threat model covers all 7 threat actors', () => {
+  const c = read('docs/security/threat-model.md');
+  for (let i = 1; i <= 7; i++) {
+    assert.ok(c.includes(`Threat Actor ${i}`), `Missing Threat Actor ${i}`);
+  }
+});
+
+test('ADR index lists all 20 ADRs', () => {
+  const c = read('docs/architecture/decision-records-index.md');
+  for (let i = 1; i <= 20; i++) {
+    const adrRef = `ADR-${String(i).padStart(3, '0')}`;
+    assert.ok(c.includes(adrRef) || c.includes(`ADR-${i}`), `Missing ${adrRef} in index`);
+  }
+});
+
+test('SECURITY.md has responsible disclosure policy', () => {
+  const c = read('docs/security/SECURITY.md');
+  assert.ok(c.includes('disclosure') || c.includes('24 hours'), 'Should have disclosure timeline');
+});
+
+// ── All 36 commands ─────────────────────────────────────────────────────────────
+console.log('\nAll 36 commands:');
+
+const ALL_COMMANDS = [
+  // Day 1
+  'help', 'init-project', 'plan-phase', 'execute-phase', 'verify-phase', 'ship',
+  // Day 2
+  'next', 'quick', 'status', 'debug',
+  // Day 3
+  'skills', 'review', 'security-scan', 'map-codebase', 'discuss-phase',
+  // Day 4
+  'audit', 'milestone', 'complete-milestone', 'approve', 'sync-jira', 'sync-confluence',
+  // Day 5
+  'health', 'retrospective', 'profile-team', 'metrics',
+  // Day 6
+  'init-org', 'install-skill', 'publish-skill', 'pr-review', 'workspace', 'benchmark',
+  // Day 7
+  'update', 'migrate', 'plugins', 'tokens', 'release',
+];
+
+assert.strictEqual(ALL_COMMANDS.length, 36, `Expected 36 commands, have ${ALL_COMMANDS.length}`);
+console.log(`  (verifying all ${ALL_COMMANDS.length} commands)`);
+
+test('all 36 commands in .claude/commands/mindforge/', () => {
+  const missing = ALL_COMMANDS.filter(cmd => !exists(`.claude/commands/mindforge/${cmd}.md`));
+  assert.strictEqual(missing.length, 0, `Missing: ${missing.join(', ')}`);
+});
+
+test('all 36 commands mirrored to .agent/mindforge/', () => {
+  const missing = ALL_COMMANDS.filter(cmd => !exists(`.agent/mindforge/${cmd}.md`));
+  assert.strictEqual(missing.length, 0, `Missing agent mirror: ${missing.join(', ')}`);
+});
+
+test('no command file is empty (> 100 chars)', () => {
+  const tiny = ALL_COMMANDS.filter(cmd => {
+    const p = `.claude/commands/mindforge/${cmd}.md`;
+    return exists(p) && fs.statSync(p).size < 100;
+  });
+  assert.strictEqual(tiny.length, 0, `Too small: ${tiny.join(', ')}`);
+});
+
+// ── Hardening tests ───────────────────────────────────────────────────────────
+console.log('\nHardening tests:');
+
+test('SENSITIVE_EXCLUDE properly excludes .env and .key files', () => {
+  const SENSITIVE_EXCLUDE = [
+    '.env', /^\.env\..*/, /\.key$/, /\.pem$/, 'secrets', /^secrets$/
+  ];
+  const shouldExclude = (name) =>
+    SENSITIVE_EXCLUDE.some(p => typeof p === 'string' ? p === name : p.test(name));
+
+  assert.ok(shouldExclude('.env'),               '.env should be excluded');
+  assert.ok(shouldExclude('.env.local'),         '.env.local should be excluded');
+  assert.ok(shouldExclude('private.key'),        'private.key should be excluded');
+  assert.ok(shouldExclude('certificate.pem'),    'certificate.pem should be excluded');
+  assert.ok(shouldExclude('secrets'),            'secrets directory should be excluded');
+  assert.ok(!shouldExclude('package.json'),      'package.json should NOT be excluded');
+  assert.ok(!shouldExclude('.mindforge'),        '.mindforge should NOT be excluded');
+  assert.ok(!shouldExclude('src'),               'src should NOT be excluded');
+});
+
+test('SENSITIVE_EXCLUDE uses regex for .key and .pem (not glob strings)', () => {
+  const c = fs.readFileSync('bin/installer-core.js', 'utf8');
+  // Should use regex pattern /\.key$/ not string '*.key'
+  assert.ok(!c.includes('\'*.key\''), 'Should not use glob string for .key');
+  assert.ok(!c.includes('\'*.pem\''), 'Should not use glob string for .pem');
+  assert.ok(
+    c.includes('\\.key$') || c.includes('/\\.key$/') || c.includes('/.key$/'),
+    'Should use regex for .key'
+  );
+});
+
+test('migration filter uses toVersion range check (not fromVersion)', () => {
+  const c = fs.readFileSync('bin/migrations/migrate.js', 'utf8');
+  // The correct filter uses compareSemver(m.toVersion, fromVersion) > 0
+  assert.ok(
+    c.includes('m.toVersion') && c.includes('> 0'),
+    'Should use toVersion range check for migration filter'
+  );
+});
+
+test('migration has CI auto-delete of backup', () => {
+  const c = fs.readFileSync('bin/migrations/migrate.js', 'utf8');
+  assert.ok(
+    c.includes('CI') && (c.includes('auto-deleted') || c.includes('rmSync')),
+    'Should auto-delete backup in CI mode'
+  );
+});
+
+// ── Final version check ────────────────────────────────────────────────────────
+console.log('\nVersion:');
+
+test('package.json version is >= 1.0.0', () => {
+  const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+  assert.ok(pkg.version.startsWith('1.') || pkg.version.startsWith('2.'), `Expected v1 or v2, got ${pkg.version}`);
+});
+
+test('CHANGELOG.md has latest version entry', () => {
+  const c = read('CHANGELOG.md');
+  const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+  assert.ok(c.includes(pkg.version.split('-')[0]) || c.includes(pkg.version), 'CHANGELOG.md should have current version entry');
+});
+
+test('all 20 ADR files present in .planning/decisions/', () => {
+  if (!exists('.planning/decisions/')) return; // Skip if no decisions dir yet
+  const adrs = fs.readdirSync('.planning/decisions/').filter(f => f.startsWith('ADR-') && f.endsWith('.md'));
+  assert.ok(adrs.length >= 20, `Expected >= 20 ADRs, found ${adrs.length}`);
+});
+
+// ── Results ─────────────────────────────────────────────────────────────────────
+console.log(`\n${'─'.repeat(55)}`);
+console.log(`Results: ${passed} passed, ${failed} failed`);
+if (failed > 0) {
+  console.error(`\n❌  ${failed} test(s) failed — not production ready.\n`);
+  process.exit(1);
+} else {
+  console.log('\n✅  All production readiness tests passed.\n');
+}

package/.mindforge/mirrors/mirror-sre-776a1cf9/tests/release.test.js

@@ -0,0 +1,99 @@
+/**
+ * MindForge v2.0.0 — Release Validation Suite
+ *
+ * Verifies the "Autonomous Enterprise" release features.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const assert = require('assert');
+const { install, run } = require('../bin/installer-core');
+
+let passed = 0, failed = 0;
+
+function test(name, fn) {
+  try {
+    fn();
+    console.log(`  ✅  ${name}`);
+    passed++;
+  } catch (e) {
+    console.error(`  ❌  ${name}\n      ${e.message}`);
+    failed++;
+  }
+}
+
+// ── Setup ───────────────────────────────────────────────────────────────────
+const TEST_ROOT = path.join(os.tmpdir(), `mindforge-release-test-${Date.now()}`);
+fs.mkdirSync(TEST_ROOT, { recursive: true });
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+console.log('\nMindForge v2.0.0 — Release Validation\n');
+
+test('Multi-runtime: RUNTIMES map contains all 6 platforms', () => {
+  const { RUNTIMES } = require('../bin/installer-core');
+  const expected = ['claude', 'antigravity', 'cursor', 'opencode', 'gemini', 'copilot'];
+  expected.forEach(rt => {
+    assert.ok(RUNTIMES[rt], `Missing runtime: ${rt}`);
+    assert.ok(RUNTIMES[rt].entryFile, `Missing entryFile for ${rt}`);
+  });
+});
+
+test('Installer: adapters generate preambles for Cursor/Copilot', () => {
+  const { generateEntryContent } = require('../bin/installer-core');
+  const baseContent = '# Project Rules\n\nRule 1: Always use MindForge.';
+  
+  const cursor = generateEntryContent('cursor', baseContent);
+  assert.ok(cursor.includes('MindForge command reference'), 'Cursor missing preamble');
+  
+  const copilot = generateEntryContent('copilot', baseContent);
+  assert.ok(copilot.includes('MindForge command reference'), 'Copilot missing preamble');
+});
+
+test('Installer: Gemini adapter performs model/path substitutions', () => {
+  const { generateEntryContent } = require('../bin/installer-core');
+  const baseContent = 'Use CLAUDE.md for rules. Use model claude-3-5-sonnet-20241022.';
+  
+  const gemini = generateEntryContent('gemini', baseContent);
+  assert.ok(gemini.includes('GEMINI.md'), 'Gemini missing filename replacement');
+  assert.ok(gemini.includes('gemini-2.0-flash-exp'), 'Gemini missing model replacement');
+  assert.ok(!gemini.includes('claude-3-5-sonnet'), 'Gemini still contains Claude model name');
+});
+
+test('Migration: 1.0.0 → 2.0.0 backfills AUDIT.jsonl', async () => {
+  const migration = require('../bin/migrations/1.0.0-to-2.0.0');
+  const v1Audit = JSON.stringify({ id: 'v1-1', event: 'test', timestamp: '2023' });
+  
+  // Custom mock for paths
+  const testAudit = path.join(TEST_ROOT, 'AUDIT.jsonl');
+  const testHandoff = path.join(TEST_ROOT, 'HANDOFF.json');
+  fs.writeFileSync(testAudit, v1Audit + '\n');
+  fs.writeFileSync(testHandoff, JSON.stringify({ plugin_api_version: '1.0.0' }));
+  
+  await migration.run({ audit: testAudit, handoff: testHandoff });
+  
+  const migrated = JSON.parse(fs.readFileSync(testAudit, 'utf8'));
+  assert.strictEqual(migrated.runtime, 'unknown', 'Audit runtime not backfilled');
+  assert.strictEqual(migrated.agent_id, 'migrated-v1', 'Audit agent_id not backfilled');
+  
+  const handoff = JSON.parse(fs.readFileSync(testHandoff, 'utf8'));
+  assert.strictEqual(handoff.plugin_api_version, '2.0.0', 'Handoff not upgraded to 2.0.0');
+});
+
+test('CLI: --runtime opencode parses correctly', async () => {
+  // Mock run() logic check indirectly via argument parsing logic
+  const args = ['--runtime', 'opencode', '--local'];
+  let runtime = null;
+  const rtIdx = args.indexOf('--runtime');
+  if (rtIdx !== -1 && args[rtIdx + 1]) {
+    runtime = args[rtIdx + 1].toLowerCase();
+  }
+  assert.strictEqual(runtime, 'opencode', 'Failed to parse --runtime flag');
+});
+
+console.log(`\n${'─'.repeat(55)}`);
+console.log(`Results: ${passed} passed, ${failed} failed`);
+
+if (failed > 0) process.exit(1);
+else console.log('\n✅  v2.0.0 Release Validation Passed.\n');