mindforge-cc 8.1.1 → 8.2.0

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

@@ -0,0 +1,91 @@
+/**
+ * MindForge Semantic Hub & Ghost Pattern Verification
+ * v4.2.5 — Cross-Repo Sync Verification
+ */
+
+const semanticHub = require('../bin/memory/semantic-hub');
+const ghostDetector = require('../bin/memory/ghost-pattern-detector');
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const os = require('node:os');
+
+async function verifyMemoryMesh() {
+  console.log('--- MindForge Memory Mesh Verification ---');
+
+  // Override global path for testing
+  const testGlobalBase = path.join(os.tmpdir(), 'mindforge-global-test');
+  semanticHub.globalPath = testGlobalBase;
+
+  try {
+    // 1. Initialize Global Store Mock
+    await fs.mkdir(testGlobalBase, { recursive: true });
+    
+    // Seed a "Ghost Pattern" (failure from another repo)
+    const ghostPattern = {
+      id: 'GHOST-001',
+      type: 'ghost-pattern',
+      tags: ['security', 'env-leak', 'failure', 'p0'],
+      failureContext: 'Environment variables leaked via insecure logging in Repo-X.',
+      mitigationStrategy: 'Use MindForge-Nexus localized masking.'
+    };
+    
+    await fs.writeFile(
+      path.join(testGlobalBase, 'pattern-library.jsonl'), 
+      JSON.stringify(ghostPattern) + '\n'
+    );
+
+    console.log('[Test 1] Global Seeded with Ghost Pattern:');
+    console.log(` - Ghost ID: ${ghostPattern.id} (Tags: ${ghostPattern.tags.join(',')})`);
+    console.log(' ✅ Success');
+
+    // 2. Proposed (Local) Pattern Analysis
+    const proposedPattern = {
+      id: 'LOCAL-ADR-005',
+      tags: ['security', 'env-leak'], // Overlaps with the ghost pattern!
+      description: 'New logging service implementation.'
+    };
+
+    console.log(`[Test 2] Analyzing Proactive Risk for: ${proposedPattern.id}...`);
+    const risks = await ghostDetector.analyzeRisk(proposedPattern);
+
+    if (risks.length === 0) {
+      throw new Error('FAILED: Ghost pattern detector missed the overlap');
+    }
+
+    console.log(` - Detected ${risks.length} Risk(s):`);
+    risks.forEach(r => {
+      console.log(`   [${r.riskLevel}] ${r.description}`);
+      console.log(`   [Mitigation] ${r.mitigation}`);
+    });
+
+    if (risks[0].riskLevel !== 'CRITICAL') {
+      throw new Error('FAILED: Risk level calculation incorrect');
+    }
+    console.log(' ✅ Success');
+
+    // 3. Library Sync Logic
+    console.log('[Test 3] Syncing Local pattern-library to Global...');
+    // Ensure local library exists for testing
+    const localLib = '.mindforge/memory/pattern-library.jsonl';
+    const localContent = JSON.stringify({ id: 'LOCAL-SAFE-001', tags: ['performance'], description: 'Standard optimization' });
+    await fs.writeFile(localLib, localContent + '\n');
+
+    await semanticHub.syncLibrary('pattern-library.jsonl');
+    
+    // Verify sync
+    const globalData = await fs.readFile(path.join(testGlobalBase, 'pattern-library.jsonl'), 'utf8');
+    if (!globalData.includes('LOCAL-SAFE-001')) {
+      throw new Error('FAILED: Local pattern not found in global store after sync');
+    }
+    console.log(' ✅ Success');
+
+    console.log('--- All Memory Mesh Tests Passed 🚀 ---');
+    process.exit(0);
+  } catch (err) {
+    console.error('--- Memory Mesh Verification Failed ❌ ---');
+    console.error(err.message);
+    process.exit(1);
+  }
+}
+
+verifyMemoryMesh();

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

@@ -0,0 +1,87 @@
+/**
+ * MindForge Sharding & Tri-Tier Memory Tests
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const assert = require('assert');
+
+const SHARD_HELPER = 'node bin/shard-helper.js';
+
+// Setup Mock Data
+const mockHandoff = {
+  schema_version: '2.1.0',
+  hot_context: {
+    active_decisions: [
+      { id: 'ADR-001', topic: 'Use Kafka', content: 'Architecture decision to use Kafka for messaging.' },
+      { id: 'DESC-002', topic: 'Typo in README', content: 'Minor fix for a typo.' }
+    ],
+    recent_discoveries: [
+      { id: 'DISC-001', topic: 'Auth latency', content: 'Auth service is slow due to DB indexing.' }
+    ]
+  }
+};
+
+const mockShardDir = '.planning/memories/';
+if (!fs.existsSync(mockShardDir)) fs.mkdirSync(mockShardDir, { recursive: true });
+
+const mockShardLine = JSON.stringify({ id: 'WARM-001', topic: 'Database Schema', content: 'The user table has been updated with a new email field.' });
+fs.writeFileSync(path.join(mockShardDir, 'WARM-SHARD-TEST.jsonl'), mockShardLine + '\n');
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+console.log('\nMindForge V3 — Sharding Tests\n');
+
+try {
+  // Test 1: SRD Analysis
+  console.log('Test 1: SRD Analysis...');
+  const tempHandoff = 'temp-handoff.json';
+  fs.writeFileSync(tempHandoff, JSON.stringify(mockHandoff));
+  
+  const analysisOutput = execSync(`${SHARD_HELPER} --analyse ${tempHandoff}`).toString();
+  const scored = JSON.parse(analysisOutput);
+  
+  assert.ok(scored.length === 3, 'Should score all 3 mock items');
+  assert.ok(scored[0].id === 'ADR-001', 'ADR should have highest SRD');
+  assert.ok(scored[0].checksum, 'Should generate checksum');
+  assert.ok(scored[0].tags.includes('kafka'), 'Should generate semantic tags');
+  
+  console.log('  ✅ SRD Analysis & Hardening (Tags/Checksums) passed');
+
+  // Test 2: Integrity Verification
+  console.log('Test 2: Integrity Verification...');
+  const shardPath = path.join(mockShardDir, 'INTEGRITY-TEST.jsonl');
+  const validItem = JSON.parse(JSON.stringify(scored[0]));
+  fs.writeFileSync(shardPath, JSON.stringify(validItem) + '\n');
+  
+  const verifyOutput = execSync(`${SHARD_HELPER} --verify ${shardPath}`).toString();
+  assert.ok(verifyOutput.includes('verified'), 'Should verify valid shard');
+  
+  console.log('  ✅ Integrity Verification passed');
+
+  // Test 2: Semantic Retrieval
+  console.log('Test 2: Semantic Retrieval...');
+  const retrievalOutput = execSync(`${SHARD_HELPER} --retrieve "database email"`).toString();
+  const retrieved = JSON.parse(retrievalOutput);
+  
+  assert.ok(retrieved.length > 0, 'Should retrieve relevant shard');
+  assert.ok(retrieved[0].topic === 'Database Schema', 'Should match database keyword');
+  
+  console.log('  ✅ Semantic Retrieval passed');
+
+  // Test 3: Empty retrieval
+  console.log('Test 3: Empty Retrieval...');
+  const emptyOutput = execSync(`${SHARD_HELPER} --retrieve "nonexistent keyword"`).toString();
+  const emptyRetrieved = JSON.parse(emptyOutput);
+  assert.strictEqual(emptyRetrieved.length, 0, 'Should return empty array for no match');
+  console.log('  ✅ Empty Retrieval passed');
+
+  fs.unlinkSync(tempHandoff);
+  console.log('\n✅ All Sharding Tests Passed!\n');
+
+} catch (err) {
+  console.error('\n❌ Sharding Tests Failed:');
+  console.error(err.message);
+  process.exit(1);
+}

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

@@ -0,0 +1,389 @@
+/**
+ * MindForge Skills Platform Tests
+ * Run: node tests/skills-platform.test.js
+ */
+
+const fs = require('fs');
+const path = require('path');
+const assert = require('assert');
+
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+  try {
+    fn();
+    console.log(`  ✅ ${name}`);
+    passed++;
+  } catch (err) {
+    console.error(`  ❌ ${name}`);
+    console.error(`     ${err.message}`);
+    failed++;
+  }
+}
+
+// ── Skill frontmatter parser ──────────────────────────────────────────────────
+function parseSkillFrontmatter(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  if (!content.startsWith('---')) {
+    throw new Error(`${filePath}: missing frontmatter (must start with ---)`);
+  }
+  const end = content.indexOf('---', 3);
+  if (end === -1) throw new Error(`${filePath}: unclosed frontmatter`);
+  const fm = content.slice(3, end).trim();
+
+  const result = {};
+  fm.split('\n').forEach(line => {
+    const colon = line.indexOf(':');
+    if (colon === -1) return;
+    const key = line.slice(0, colon).trim();
+    const val = line.slice(colon + 1).trim();
+    result[key] = val;
+  });
+  return result;
+}
+
+// ── Semver validator ──────────────────────────────────────────────────────────
+function isValidSemver(version) {
+  return /^\d+\.\d+\.\d+$/.test(version);
+}
+
+// ── Skills directory scanner ──────────────────────────────────────────────────
+function getAllSkillPaths() {
+  const skillsDir = '.mindforge/skills';
+  if (!fs.existsSync(skillsDir)) return [];
+  return fs.readdirSync(skillsDir)
+    .map(dir => path.join(skillsDir, dir, 'SKILL.md'))
+    .filter(p => fs.existsSync(p));
+}
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+console.log('\nMindForge Day 3 — Skills Platform Tests\n');
+
+console.log('Skills directory structure:');
+
+test('skills directory exists', () => {
+  assert.ok(fs.existsSync('.mindforge/skills'), 'Missing .mindforge/skills/');
+});
+
+test('all 10 skill directories exist', () => {
+  const required = [
+    'security-review', 'code-quality', 'api-design', 'testing-standards',
+    'documentation', 'performance', 'accessibility', 'data-privacy',
+    'incident-response', 'database-patterns'
+  ];
+  required.forEach(skill => {
+    const p = `.mindforge/skills/${skill}/SKILL.md`;
+    assert.ok(fs.existsSync(p), `Missing: ${p}`);
+  });
+});
+
+test('engine skills directory has all 4 engine files', () => {
+  const required = ['registry.md', 'loader.md', 'versioning.md', 'conflict-resolver.md'];
+  required.forEach(f => {
+    const p = `.mindforge/engine/skills/${f}`;
+    assert.ok(fs.existsSync(p), `Missing: ${p}`);
+  });
+});
+
+console.log('\nSkill frontmatter validation:');
+
+const skillPaths = getAllSkillPaths();
+test(`found ${skillPaths.length} skill files to validate`, () => {
+  assert.ok(skillPaths.length >= 10, `Expected >= 10 skill files, found ${skillPaths.length}`);
+});
+
+skillPaths.forEach(skillPath => {
+  const skillName = skillPath.split('/').slice(-2)[0];
+
+  test(`${skillName}: has valid frontmatter`, () => {
+    const fm = parseSkillFrontmatter(skillPath);
+    assert.ok(fm.name, 'Missing name field');
+    assert.ok(fm.version, 'Missing version field');
+    assert.ok(fm.status, 'Missing status field');
+    assert.ok(fm.triggers, 'Missing triggers field');
+  });
+
+  test(`${skillName}: name matches directory`, () => {
+    const fm = parseSkillFrontmatter(skillPath);
+    assert.strictEqual(fm.name, skillName, `Skill name "${fm.name}" doesn't match directory "${skillName}"`);
+  });
+
+  test(`${skillName}: version is valid semver`, () => {
+    const fm = parseSkillFrontmatter(skillPath);
+    assert.ok(isValidSemver(fm.version), `Invalid semver: "${fm.version}"`);
+  });
+
+  test(`${skillName}: has at least 10 trigger keywords`, () => {
+    const fm = parseSkillFrontmatter(skillPath);
+    const triggers = fm.triggers.split(',').map(t => t.trim()).filter(Boolean);
+    assert.ok(triggers.length >= 10, `Too few triggers: ${triggers.length} (min 10)`);
+  });
+
+  test(`${skillName}: status is a valid value`, () => {
+    const fm = parseSkillFrontmatter(skillPath);
+    const validStatuses = ['stable', 'beta', 'alpha', 'deprecated'];
+    assert.ok(validStatuses.includes(fm.status), `Invalid status: "${fm.status}"`);
+  });
+
+  test(`${skillName}: has mandatory actions section`, () => {
+    const content = fs.readFileSync(skillPath, 'utf8');
+    assert.ok(
+      content.includes('## Mandatory actions') || content.includes('mandatory actions'),
+      'Missing mandatory actions section'
+    );
+  });
+
+  test(`${skillName}: has self-check or checklist section`, () => {
+    const content = fs.readFileSync(skillPath, 'utf8');
+    assert.ok(
+      content.includes('checklist') || content.includes('self-check') || content.includes('- [ ]'),
+      'Missing checklist or self-check section'
+    );
+  });
+});
+
+console.log('\nManifest validation:');
+
+test('MANIFEST.md exists', () => {
+  assert.ok(fs.existsSync('.mindforge/org/skills/MANIFEST.md'), 'Missing MANIFEST.md');
+});
+
+test('registry defines manifest path and missing-manifest handling', () => {
+  const registry = fs.readFileSync('.mindforge/engine/skills/registry.md', 'utf8');
+  assert.ok(
+    registry.includes('.mindforge/org/skills/MANIFEST.md'),
+    'Registry missing explicit manifest path'
+  );
+  assert.ok(
+    registry.includes('MANIFEST.md was missing') || registry.includes('If MANIFEST.md does not exist'),
+    'Registry missing missing-manifest handling'
+  );
+});
+
+test('MANIFEST.md registers all 10 core skills', () => {
+  const content = fs.readFileSync('.mindforge/org/skills/MANIFEST.md', 'utf8');
+  const requiredSkills = [
+    'security-review', 'code-quality', 'api-design', 'testing-standards',
+    'documentation', 'performance', 'accessibility', 'data-privacy',
+    'incident-response', 'database-patterns'
+  ];
+  requiredSkills.forEach(skill => {
+    assert.ok(content.includes(skill), `MANIFEST.md missing skill: ${skill}`);
+  });
+});
+
+test('MANIFEST.md has schema version header', () => {
+  const content = fs.readFileSync('.mindforge/org/skills/MANIFEST.md', 'utf8');
+  assert.ok(content.includes('Schema version') || content.includes('schema version:'), 'Missing schema version');
+});
+
+console.log('\nTrigger keyword uniqueness (within Tier 1):');
+
+test('no duplicate triggers between Tier 1 skills at exact match', () => {
+  const triggerMap = {};
+  const conflicts = [];
+
+  getAllSkillPaths().forEach(skillPath => {
+    const fm = parseSkillFrontmatter(skillPath);
+    const skillName = fm.name;
+    const triggers = fm.triggers.split(',').map(t => t.trim().toLowerCase()).filter(Boolean);
+
+    triggers.forEach(trigger => {
+      if (triggerMap[trigger] && triggerMap[trigger] !== skillName) {
+        conflicts.push(`"${trigger}": ${triggerMap[trigger]} vs ${skillName}`);
+      } else {
+        triggerMap[trigger] = skillName;
+      }
+    });
+  });
+
+  // Conflicts are allowed (Type 1 in conflict-resolver.md) but should be minimal
+  // Flag if more than 5 conflicts exist (suggests poor trigger hygiene)
+  assert.ok(
+    conflicts.length <= 5,
+    `Too many trigger conflicts (${conflicts.length} > 5): ${conflicts.slice(0, 3).join(', ')}`
+  );
+});
+
+console.log('\nPersona override system:');
+
+test('personas/overrides directory exists', () => {
+  assert.ok(fs.existsSync('.mindforge/personas/overrides'), 'Missing personas/overrides directory');
+});
+
+test('personas/overrides/README.md exists and has content', () => {
+  const p = '.mindforge/personas/overrides/README.md';
+  assert.ok(fs.existsSync(p), 'Missing overrides README.md');
+  const content = fs.readFileSync(p, 'utf8');
+  assert.ok(content.length > 200, 'README.md too short');
+  assert.ok(content.includes('override'), 'README.md should explain overrides');
+});
+
+console.log('\nNew commands (21 total):');
+
+const allCommands = [
+  'help', 'init-project', 'plan-phase', 'execute-phase', 'verify-phase', 'ship',  // Day 1
+  'next', 'quick', 'status', 'debug',                                               // Day 2
+  'skills', 'review', 'security-scan', 'map-codebase', 'discuss-phase',            // Day 3
+  'audit', 'milestone', 'complete-milestone', 'approve', 'sync-jira',              // Day 4
+  'sync-confluence'
+];
+
+test('all 21 commands exist in .claude/commands/mindforge/', () => {
+  allCommands.forEach(cmd => {
+    const p = `.claude/commands/mindforge/${cmd}.md`;
+    assert.ok(fs.existsSync(p), `Missing command: ${p}`);
+  });
+});
+
+test('all 21 commands mirrored to .agent/mindforge/', () => {
+  allCommands.forEach(cmd => {
+    const p = `.agent/mindforge/${cmd}.md`;
+    assert.ok(fs.existsSync(p), `Missing mirrored command: ${p}`);
+  });
+});
+
+test('command files are not empty', () => {
+  allCommands.forEach(cmd => {
+    const p = `.claude/commands/mindforge/${cmd}.md`;
+    if (fs.existsSync(p)) {
+      const size = fs.statSync(p).size;
+      assert.ok(size > 200, `Command file too small (${size} bytes): ${cmd}.md`);
+    }
+  });
+});
+
+test('command files include usage or step markers', () => {
+  allCommands.forEach(cmd => {
+    const p = `.claude/commands/mindforge/${cmd}.md`;
+    const content = fs.readFileSync(p, 'utf8');
+    const hasMarker = /Usage:|## Step|## Pre-check|Steps/gi.test(content);
+    assert.ok(hasMarker, `Command missing usage/steps markers: ${cmd}.md`);
+  });
+});
+
+console.log('\nSkills loader ordering:');
+
+test('loader prioritizes tiers and protects security skill from summarisation', () => {
+  const content = fs.readFileSync('.mindforge/engine/skills/loader.md', 'utf8');
+  assert.ok(
+    content.includes('Project → Org → Core'),
+    'Loader missing tier priority order'
+  );
+  assert.ok(
+    content.toLowerCase().includes('never summarise a security skill'),
+    'Loader missing security summarisation rule'
+  );
+});
+
+console.log('\nHardening-prompted tests:');
+
+test('all MANIFEST.md skill paths resolve to existing files', () => {
+  const content = fs.readFileSync('.mindforge/org/skills/MANIFEST.md', 'utf8');
+  const pathPattern = /\.mindforge\/skills\/[\w-]+\/SKILL\.md/g;
+  const paths = content.match(pathPattern) || [];
+  assert.ok(paths.length >= 10, `Expected >= 10 paths in manifest, found ${paths.length}`);
+  paths.forEach(p => {
+    assert.ok(fs.existsSync(p), `MANIFEST.md references missing file: ${p}`);
+  });
+});
+
+test('database-patterns SKILL.md has compound cursor documentation', () => {
+  const content = fs.readFileSync('.mindforge/skills/database-patterns/SKILL.md', 'utf8');
+  assert.ok(
+    content.includes('compound cursor') || content.includes('cursor_time') || content.includes('(created_at, id)'),
+    'database-patterns should document compound cursor pagination'
+  );
+});
+
+test('skills loader has injection guard section', () => {
+  const content = fs.readFileSync('.mindforge/engine/skills/loader.md', 'utf8');
+  assert.ok(
+    content.includes('injection') || content.includes('IGNORE ALL PREVIOUS'),
+    'Loader should have injection guard documentation'
+  );
+});
+
+test('skills loader has file-name matching', () => {
+  const content = fs.readFileSync('.mindforge/engine/skills/loader.md', 'utf8');
+  assert.ok(
+    content.includes('File NAME matching') || content.includes('file name') || content.includes('file-name'),
+    'Loader should have file-name matching (not just directory matching)'
+  );
+});
+
+test('plan-phase command references CONTEXT.md', () => {
+  const content = fs.readFileSync('.claude/commands/mindforge/plan-phase.md', 'utf8');
+  assert.ok(
+    content.includes('CONTEXT.md'),
+    'plan-phase should read CONTEXT.md from discuss-phase'
+  );
+});
+
+test('map-codebase has secret exclusion list', () => {
+  const content = fs.readFileSync('.claude/commands/mindforge/map-codebase.md', 'utf8');
+  assert.ok(
+    content.includes('.env') || content.includes('EXCLUDED') || content.includes('secret'),
+    'map-codebase should exclude .env and secret files'
+  );
+});
+
+test('security-scan has visibility guidance', () => {
+  const content = fs.readFileSync('.claude/commands/mindforge/security-scan.md', 'utf8');
+  assert.ok(
+    content.includes('public repository') || content.includes('.gitignore'),
+    'security-scan should mention report visibility guidance'
+  );
+});
+
+test('accessibility skill mentions reduced motion', () => {
+  const content = fs.readFileSync('.mindforge/skills/accessibility/SKILL.md', 'utf8');
+  assert.ok(
+    content.includes('reduced-motion') || content.includes('prefers-reduced-motion') || content.includes('reduced motion'),
+    'Accessibility skill should cover reduced motion preference'
+  );
+});
+
+test('performance skill marks latency targets as adjustable', () => {
+  const content = fs.readFileSync('.mindforge/skills/performance/SKILL.md', 'utf8');
+  assert.ok(
+    content.includes('NFR') || content.includes('override') || content.includes('adjust'),
+    'Performance skill should note that targets are adjustable per NFRs'
+  );
+});
+
+test('data-privacy skill covers consent withdrawal', () => {
+  const content = fs.readFileSync('.mindforge/skills/data-privacy/SKILL.md', 'utf8');
+  assert.ok(
+    content.includes('withdraw') || content.includes('withdrawal') || content.includes('opt-out'),
+    'Data privacy skill should cover consent withdrawal requirement'
+  );
+});
+
+test('package.json version is at least 0.3.0', () => {
+  const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+  const [major, minor] = pkg.version.split('.').map(Number);
+  assert.ok(
+    major > 0 || (major === 0 && minor >= 3),
+    `package.json version ${pkg.version} should be >= 0.3.0 for Day 3 skill compatibility`
+  );
+});
+
+test('CHANGELOG.md exists and has 0.3.0 entry', () => {
+  assert.ok(fs.existsSync('CHANGELOG.md'), 'CHANGELOG.md should exist after Day 3');
+  const content = fs.readFileSync('CHANGELOG.md', 'utf8');
+  assert.ok(content.includes('0.3.0'), 'CHANGELOG.md should have a 0.3.0 entry');
+});
+
+// ── Results ───────────────────────────────────────────────────────────────────
+console.log(`\n${'─'.repeat(50)}`);
+console.log(`Results: ${passed} passed, ${failed} failed`);
+
+if (failed > 0) {
+  console.error(`\n❌ ${failed} test(s) failed.\n`);
+  process.exit(1);
+} else {
+  console.log('\n✅ All skills platform tests passed.\n');
+}

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

@@ -0,0 +1,76 @@
+/**
+ * MindForge — Pillar VI: Sovereign Reason Enclave (SRE) ZK-Proof Test
+ * Verifies that confidential reasoning is masked in logs while providing verifiable compliance proofs.
+ */
+'use strict';
+
+const { NexusTracer } = require('../bin/engine/nexus-tracer');
+const SREManager = require('../bin/engine/sre-manager');
+const ztai = require('../bin/governance/ztai-manager');
+const fs = require('fs');
+const path = require('path');
+
+async function runTest() {
+  console.log('--- STARTING SRE ZK-PROOF TEST ---');
+
+  const tracer = new NexusTracer({
+    auditPath: path.join(__dirname, 'test_audit.jsonl'),
+    did: 'did:mindforge:agent:test-enterprise'
+  });
+
+  // Seed the ZTAI Registry for the test agent
+  await ztai.providers.enclave.generate('did:mindforge:agent:test-enterprise');
+  ztai.agentRegistry.set('did:mindforge:agent:test-enterprise', {
+    providerType: 'enclave',
+    tier: 3
+  });
+
+  const sre = new SREManager();
+  tracer.startTrace();
+
+  // Test Case 1: Standard Reasoning (Plaintext)
+  console.log('\n[TEST] Recording standard reasoning...');
+  const span1 = await tracer.startSpan('standard-task');
+  await tracer.recordReasoning(span1, 'test-agent', 'This is a public thought.');
+  await tracer.endSpan(span1);
+
+  // Test Case 2: Confidential Reasoning (SRE Isolated)
+  console.log('\n[TEST] Recording confidential reasoning (SRE)...');
+  const span2 = await tracer.startSpan('confidential-task', { is_confidential: true, tier: 3 });
+  
+  // The actual thought that should NOT be in the log
+  const privateThought = 'PRIVATE_IP: The secret formula is 42.';
+  await tracer.recordReasoning(span2, 'test-agent', privateThought);
+  await tracer.endSpan(span2);
+
+  // Verification: Read the audit log
+  console.log('\n[VERIFICATION] Analyzing audit log output...');
+  const logContent = fs.readFileSync(path.join(__dirname, 'test_audit.jsonl'), 'utf8');
+  const lines = logContent.trim().split('\n').map(JSON.parse);
+
+  const reasoningTraces = lines.filter(l => l.event === 'reasoning_trace');
+  const sreProofs = lines.filter(l => l.event === 'sre_proof_logged');
+
+  console.log(`Standard Traces found: ${reasoningTraces.length}`);
+  console.log(`SRE Proofs found: ${sreProofs.length}`);
+
+  if (sreProofs.length > 0) {
+    const proof = sreProofs[0].certificate;
+    console.log(`\nProof Certificate Message: ${proof.message}`);
+    console.log(`Proof Status: ${proof.status}`);
+    
+    // Verify the proof
+    const isValid = sre.verifyZKProof(proof);
+    console.log(`Proof Cryptographic Validation: ${isValid ? 'PASSED' : 'FAILED'}`);
+    
+    // Check for leakage
+    const leaked = logContent.includes('PRIVATE_IP');
+    console.log(`Confidential Content Leakage Check: ${leaked ? 'FAILED (Content Leaked!)' : 'PASSED (No Leakage)'}`);
+  }
+
+  // Cleanup
+  fs.unlinkSync(path.join(__dirname, 'test_audit.jsonl'));
+  console.log('\n--- SRE TEST COMPLETE ---');
+}
+
+runTest().catch(console.error);

package/.mindforge/mirrors/mirror-sre-776a1cf9/tests/swarms.test.md

@@ -0,0 +1,21 @@
+# Swarm Orchestration Verification Tests
+
+## Test 1: Swarm Eligibility Detection
+- **Input:** PLAN with `difficulty: 8.5`, `impact: HIGH`, touching `src/auth/login.ts`.
+- **Expected:** `SwarmController` returns `swarm_cluster` with `SecuritySwarm` template.
+
+## Test 2: Multi-Disciplinary Swarm Trigger
+- **Input:** PLAN with `files: ["src/ui/Button.tsx", "src/api/auth.ts"]`.
+- **Expected:** `SwarmController` returns `FullStackSwarm`.
+
+## Test 3: Micro-Persona Generation
+- **Input:** Base `developer.md`, Context Patch for `zod`.
+- **Expected:** `PersonaFactory` generates a valid micro-persona with `Zod` validation rules in `<specialist_knowledge>`.
+
+## Test 4: Swarm State Initialization
+- **Action:** Execute a `UISwarm` in a mock Wave.
+- **Expected:** `.planning/phases/1/SWARM-STATE-1.json` is created with members: `["ui-auditor", "developer", "accessibility"]`.
+
+## Test 5: Summary Consolidation
+- **Action:** `ui-auditor` (leader) writes `SWARM-SUMMARY-1-1.md` after fetching member notes from `SWARM-STATE-1.json`.
+- **Expected:** Single summary file exists containing all specialist findings.