mindforge-cc 8.1.1 → 8.2.0

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

@@ -0,0 +1,336 @@
+/**
+ * MindForge Wave Engine Tests
+ * Tests: dependency parsing, wave grouping, and execution planning
+ * Run: node tests/wave-engine.test.js
+ */
+
+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++;
+  }
+}
+
+// ── Simulate the dependency parser and wave grouper ───────────────────────────
+
+/**
+ * Simulates parsing a PLAN file's dependency field
+ * In real execution, this reads from the actual XML PLAN files
+ */
+function parseDependencies(depString) {
+  if (!depString || depString.trim().toLowerCase() === 'none') return [];
+  return depString.split(',').map(d => d.trim()).filter(Boolean);
+}
+
+/**
+ * Simulates the wave grouping algorithm (Kahn's topological sort)
+ * Input: { "01": { dependsOn: [] }, "02": { dependsOn: ["01"] }, ... }
+ * Output: [["01"], ["02"], ...]
+ */
+function groupIntoWaves(graph) {
+  const remaining = new Set(Object.keys(graph));
+  const completed = new Set();
+  const waves = [];
+
+  while (remaining.size > 0) {
+    const wave = [];
+    for (const id of remaining) {
+      const deps = graph[id].dependsOn;
+      if (deps.every(d => completed.has(d))) {
+        wave.push(id);
+      }
+    }
+
+    if (wave.length === 0 && remaining.size > 0) {
+      throw new Error(`Circular dependency detected among: ${[...remaining].join(', ')}`);
+    }
+
+    waves.push(wave.sort());
+    wave.forEach(id => { completed.add(id); remaining.delete(id); });
+  }
+
+  return waves;
+}
+
+/**
+ * Detects circular dependencies
+ */
+function hasCircularDependency(graph) {
+  try {
+    groupIntoWaves(graph);
+    return false;
+  } catch {
+    return true;
+  }
+}
+
+/**
+ * Detects file conflicts between plans
+ */
+function findFileConflicts(plans) {
+  const fileMap = {};
+  const conflicts = [];
+
+  plans.forEach(({ id, files }) => {
+    files.forEach(file => {
+      if (fileMap[file]) {
+        conflicts.push({ file, plans: [fileMap[file], id] });
+      } else {
+        fileMap[file] = id;
+      }
+    });
+  });
+
+  return conflicts;
+}
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+console.log('\nMindForge Day 2 — Wave Engine Tests\n');
+
+console.log('Dependency parsing:');
+
+test('parses "none" as empty dependencies', () => {
+  assert.deepStrictEqual(parseDependencies('none'), []);
+  assert.deepStrictEqual(parseDependencies('None'), []);
+  assert.deepStrictEqual(parseDependencies('NONE'), []);
+});
+
+test('parses single dependency', () => {
+  assert.deepStrictEqual(parseDependencies('01'), ['01']);
+});
+
+test('parses multiple dependencies', () => {
+  assert.deepStrictEqual(parseDependencies('01, 02, 03'), ['01', '02', '03']);
+});
+
+test('handles whitespace in dependency list', () => {
+  assert.deepStrictEqual(parseDependencies('01,02,  03'), ['01', '02', '03']);
+});
+
+test('parses empty string as no dependencies', () => {
+  assert.deepStrictEqual(parseDependencies(''), []);
+});
+
+console.log('\nWave grouping algorithm:');
+
+test('single task with no dependencies → 1 wave', () => {
+  const graph = { '01': { dependsOn: [] } };
+  const waves = groupIntoWaves(graph);
+  assert.deepStrictEqual(waves, [['01']]);
+});
+
+test('two independent tasks → 1 wave with both', () => {
+  const graph = {
+    '01': { dependsOn: [] },
+    '02': { dependsOn: [] },
+  };
+  const waves = groupIntoWaves(graph);
+  assert.strictEqual(waves.length, 1);
+  assert.deepStrictEqual(waves[0].sort(), ['01', '02']);
+});
+
+test('sequential dependency chain → 3 waves, 1 task each', () => {
+  const graph = {
+    '01': { dependsOn: [] },
+    '02': { dependsOn: ['01'] },
+    '03': { dependsOn: ['02'] },
+  };
+  const waves = groupIntoWaves(graph);
+  assert.strictEqual(waves.length, 3);
+  assert.deepStrictEqual(waves[0], ['01']);
+  assert.deepStrictEqual(waves[1], ['02']);
+  assert.deepStrictEqual(waves[2], ['03']);
+});
+
+test('diamond dependency (fan-out then fan-in)', () => {
+  const graph = {
+    '01': { dependsOn: [] },
+    '02': { dependsOn: ['01'] },
+    '03': { dependsOn: ['01'] },
+    '04': { dependsOn: ['02', '03'] },
+  };
+  const waves = groupIntoWaves(graph);
+  assert.strictEqual(waves.length, 3);
+  assert.deepStrictEqual(waves[0], ['01']);
+  assert.deepStrictEqual(waves[1].sort(), ['02', '03']);
+  assert.deepStrictEqual(waves[2], ['04']);
+});
+
+test('5-plan realistic example (user model → api → checkout)', () => {
+  const graph = {
+    '01': { dependsOn: [] },
+    '02': { dependsOn: [] },
+    '03': { dependsOn: ['01'] },
+    '04': { dependsOn: ['02'] },
+    '05': { dependsOn: ['03', '04'] },
+  };
+  const waves = groupIntoWaves(graph);
+  assert.strictEqual(waves.length, 3);
+  assert.deepStrictEqual(waves[0].sort(), ['01', '02']);
+  assert.deepStrictEqual(waves[1].sort(), ['03', '04']);
+  assert.deepStrictEqual(waves[2], ['05']);
+});
+
+console.log('\nCircular dependency detection:');
+
+test('detects direct circular dependency (A → B → A)', () => {
+  const graph = {
+    '01': { dependsOn: ['02'] },
+    '02': { dependsOn: ['01'] },
+  };
+  assert.strictEqual(hasCircularDependency(graph), true);
+});
+
+test('detects indirect circular dependency (A → B → C → A)', () => {
+  const graph = {
+    '01': { dependsOn: ['03'] },
+    '02': { dependsOn: ['01'] },
+    '03': { dependsOn: ['02'] },
+  };
+  assert.strictEqual(hasCircularDependency(graph), true);
+});
+
+test('does not false-positive on valid DAG', () => {
+  const graph = {
+    '01': { dependsOn: [] },
+    '02': { dependsOn: ['01'] },
+    '03': { dependsOn: ['01'] },
+    '04': { dependsOn: ['02', '03'] },
+  };
+  assert.strictEqual(hasCircularDependency(graph), false);
+});
+
+console.log('\nFile conflict detection:');
+
+test('detects conflict when two plans modify the same file', () => {
+  const plans = [
+    { id: '01', files: ['src/models/user.ts', 'src/models/user.test.ts'] },
+    { id: '02', files: ['src/models/product.ts'] },
+    { id: '03', files: ['src/models/user.ts'] },
+  ];
+  const conflicts = findFileConflicts(plans);
+  assert.strictEqual(conflicts.length, 1);
+  assert.strictEqual(conflicts[0].file, 'src/models/user.ts');
+  assert.deepStrictEqual(conflicts[0].plans.sort(), ['01', '03']);
+});
+
+test('no conflicts when all plans touch different files', () => {
+  const plans = [
+    { id: '01', files: ['src/models/user.ts'] },
+    { id: '02', files: ['src/models/product.ts'] },
+    { id: '03', files: ['src/api/orders.ts'] },
+  ];
+  const conflicts = findFileConflicts(plans);
+  assert.strictEqual(conflicts.length, 0);
+});
+
+console.log('\nAdditional edge cases:');
+
+test('handles empty graph (zero plans)', () => {
+  const waves = groupIntoWaves({});
+  assert.deepStrictEqual(waves, []);
+});
+
+test('detects self-referencing dependency (plan depends on itself)', () => {
+  const graph = { '01': { dependsOn: ['01'] } };
+  assert.strictEqual(hasCircularDependency(graph), true);
+});
+
+test('three plans all touching the same file — all conflict', () => {
+  const plans = [
+    { id: '01', files: ['src/shared.ts'] },
+    { id: '02', files: ['src/shared.ts'] },
+    { id: '03', files: ['src/shared.ts'] },
+  ];
+  const conflicts = findFileConflicts(plans);
+  assert.ok(conflicts.length >= 2, `Expected >= 2 conflicts, got ${conflicts.length}`);
+});
+
+test('6-plan complex graph groups correctly', () => {
+  const graph = {
+    '01': { dependsOn: [] },
+    '02': { dependsOn: [] },
+    '03': { dependsOn: [] },
+    '04': { dependsOn: ['01', '02'] },
+    '05': { dependsOn: ['02', '03'] },
+    '06': { dependsOn: ['04', '05'] },
+  };
+  const waves = groupIntoWaves(graph);
+  assert.strictEqual(waves.length, 3);
+  assert.deepStrictEqual(waves[0].sort(), ['01', '02', '03']);
+  assert.deepStrictEqual(waves[1].sort(), ['04', '05']);
+  assert.deepStrictEqual(waves[2], ['06']);
+});
+
+test('single linear chain of 4 plans → 4 waves', () => {
+  const graph = {
+    '01': { dependsOn: [] },
+    '02': { dependsOn: ['01'] },
+    '03': { dependsOn: ['02'] },
+    '04': { dependsOn: ['03'] },
+  };
+  const waves = groupIntoWaves(graph);
+  assert.strictEqual(waves.length, 4);
+  waves.forEach((wave, i) => {
+    const expectedId = String(i + 1).padStart(2, '0');
+    assert.deepStrictEqual(wave, [expectedId]);
+  });
+});
+
+test('wave executor stops on first failure — does not cascade', () => {
+  // Simulates: Wave 1 has 3 tasks. Task 02 fails.
+  // Expected: tasks 01 and 03 may run, but Wave 2 must NOT start.
+  const executionLog = [];
+
+  function simulateWaveExecution(graph, failingPlan) {
+    const waves = groupIntoWaves(graph);
+    let phaseFailed = false;
+
+    for (const wave of waves) {
+      if (phaseFailed) break;
+      for (const planId of wave) {
+        if (planId === failingPlan) {
+          executionLog.push({ plan: planId, status: 'failed' });
+          phaseFailed = true;
+        } else if (!phaseFailed) {
+          executionLog.push({ plan: planId, status: 'completed' });
+        }
+      }
+    }
+    return { phaseFailed, executionLog };
+  }
+
+  const graph = {
+    '01': { dependsOn: [] },
+    '02': { dependsOn: [] },
+    '03': { dependsOn: [] },
+    '04': { dependsOn: ['01', '03'] },
+  };
+
+  const result = simulateWaveExecution(graph, '02');
+  assert.strictEqual(result.phaseFailed, true);
+  const plan04Executed = result.executionLog.some(e => e.plan === '04');
+  assert.strictEqual(plan04Executed, false, 'Plan 04 should not execute after wave failure');
+});
+
+// ── 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 wave engine tests passed.\n');
+}

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

@@ -0,0 +1,103 @@
+/**
+ * MindForge ZTAI 'Enterprise Mode' Verification Suite
+ * v4.2.5 — Hardened Verification
+ */
+
+const ztai = require('../bin/governance/ztai-manager');
+const ZTAIArchiver = require('../bin/governance/ztai-archiver');
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+async function verifyEnterpriseMode() {
+  console.log('--- MindForge ZTAI Enterprise Mode Verification ---');
+
+  try {
+    // 1. Tiered Registration & Provider Selection
+    const architectDid = await ztai.registerAgent('architect', 3);
+    const analystDid = await ztai.registerAgent('analyst', 1);
+
+    const architectInfo = ztai.getAgent(architectDid);
+    const analystInfo = ztai.getAgent(analystDid);
+
+    console.log('[Test 1] Tiered Registration:');
+    console.log(` - Architect DID: ${architectDid} (Provider: ${architectInfo.providerType}, Tier: ${architectInfo.tier})`);
+    console.log(` - Analyst DID: ${analystDid} (Provider: ${analystInfo.providerType}, Tier: ${analystInfo.tier})`);
+
+    if (architectInfo.providerType !== 'enclave' || analystInfo.providerType !== 'local') {
+      throw new Error('FAILED: Provider selection mismatch for tiers');
+    }
+    console.log(' ✅ Success');
+
+    // 2. Cross-Provider Signing
+    const data = 'Mission-critical architectural change: ADR-001';
+    const archSignature = await ztai.signData(architectDid, data);
+    const analystSignature = await ztai.signData(analystDid, data);
+
+    console.log('[Test 2] Cross-Provider Signing:');
+    console.log(` - Architect Signature (Enclave): ${archSignature.substring(0, 16)}...`);
+    console.log(` - Analyst Signature (Local): ${analystSignature.substring(0, 16)}...`);
+
+    const isArchValid = ztai.verifySignature(architectDid, data, archSignature);
+    const isAnalystValid = ztai.verifySignature(analystDid, data, analystSignature);
+
+    if (!isArchValid || !isAnalystValid) {
+      throw new Error('FAILED: Cross-provider signature verification failed');
+    }
+    console.log(' ✅ Success');
+
+    // 3. Audit Archiver & Manifest Generation
+    // Create a dummy audit log for testing
+    const auditDir = '.mindforge/audit';
+    const auditPath = path.join(auditDir, 'AUDIT.jsonl');
+    await fs.mkdir(auditDir, { recursive: true });
+    
+    const dummyEntries = [
+      { timestamp: new Date().toISOString(), event: 'spawn', did: architectDid, signature: archSignature },
+      { timestamp: new Date().toISOString(), event: 'plan', did: analystDid, signature: analystSignature }
+    ];
+    
+    await fs.writeFile(auditPath, dummyEntries.map(e => JSON.stringify(e)).join('\n'));
+
+    const archiver = new ZTAIArchiver(auditPath);
+    const manifest = await archiver.archiveAuditLog(architectDid);
+
+    console.log('[Test 3] Audit Archiver:');
+    console.log(` - Manifest Block: ${manifest.blockStart} to ${manifest.blockEnd}`);
+    console.log(` - Merkle Root: ${manifest.merkleRoot}`);
+    console.log(` - Manifest Signed by Architect: ${manifest.signature.substring(0, 16)}...`);
+
+    const { signature: manifestSig, ...manifestMetadata } = manifest;
+    const isManifestValid = ztai.verifySignature(architectDid, JSON.stringify(manifestMetadata), manifestSig);
+    if (!isManifestValid) {
+      throw new Error('FAILED: Manifest signature invalid');
+    }
+    console.log(' ✅ Success');
+
+    // 4. Key Rotation (Enclave)
+    console.log('[Test 4] Key Rotation (Enclave):');
+    const oldKey = architectInfo.publicKey;
+    await ztai.rotateKeys(architectDid);
+    const newKey = ztai.getAgent(architectDid).publicKey;
+
+    if (oldKey === newKey) {
+      throw new Error('FAILED: Enclave key rotation failed');
+    }
+    
+    // Sign with new rotated key
+    const newData = 'Post-rotation action';
+    const newSig = await ztai.signData(architectDid, newData);
+    if (!ztai.verifySignature(architectDid, newData, newSig)) {
+       throw new Error('FAILED: Signature verification failed after rotation');
+    }
+    console.log(' ✅ Success');
+
+    console.log('--- All ZTAI Enterprise Mode Tests Passed 🚀 ---');
+    process.exit(0);
+  } catch (err) {
+    console.error('--- ZTAI Verification Failed ❌ ---');
+    console.error(err.message);
+    process.exit(1);
+  }
+}
+
+verifyEnterpriseMode();

package/.planning/archive/v8-cleanup/.agents/skills/ai-image-generation/SKILL.md

@@ -0,0 +1,147 @@
+---
+name: ai-image-generation
+description: "Generate AI images with FLUX, Gemini, Grok, Seedream, Reve and 50+ models via inference.sh CLI. Models: FLUX Dev LoRA, FLUX.2 Klein LoRA, Gemini 3 Pro Image, Grok Imagine, Seedream 4.5, Reve, ImagineArt. Capabilities: text-to-image, image-to-image, inpainting, LoRA, image editing, upscaling, text rendering. Use for: AI art, product mockups, concept art, social media graphics, marketing visuals, illustrations. Triggers: flux, image generation, ai image, text to image, stable diffusion, generate image, ai art, midjourney alternative, dall-e alternative, text2img, t2i, image generator, ai picture, create image with ai, generative ai, ai illustration, grok image, gemini image"
+allowed-tools: Bash(infsh *)
+---
+
+# AI Image Generation
+
+Generate images with 50+ AI models via [inference.sh](https://inference.sh) CLI.
+
+![AI Image Generation](https://cloud.inference.sh/app/files/u/4mg21r6ta37mpaz6ktzwtt8krr/01kg0v0nz7wv0qwqjtq1cam52z.jpeg)
+
+## Quick Start
+
+> Requires inference.sh CLI (`infsh`). [Install instructions](https://raw.githubusercontent.com/inference-sh/skills/refs/heads/main/cli-install.md)
+
+```bash
+infsh login
+
+# Generate an image with FLUX
+infsh app run falai/flux-dev-lora --input '{"prompt": "a cat astronaut in space"}'
+```
+
+
+## Available Models
+
+| Model | App ID | Best For |
+|-------|--------|----------|
+| FLUX Dev LoRA | `falai/flux-dev-lora` | High quality with custom styles |
+| FLUX.2 Klein LoRA | `falai/flux-2-klein-lora` | Fast with LoRA support (4B/9B) |
+| **P-Image** | `pruna/p-image` | Fast, economical, multiple aspects |
+| **P-Image-LoRA** | `pruna/p-image-lora` | Fast with preset LoRA styles |
+| **P-Image-Edit** | `pruna/p-image-edit` | Fast image editing |
+| Gemini 3 Pro | `google/gemini-3-pro-image-preview` | Google's latest |
+| Gemini 2.5 Flash | `google/gemini-2-5-flash-image` | Fast Google model |
+| Grok Imagine | `xai/grok-imagine-image` | xAI's model, multiple aspects |
+| Seedream 4.5 | `bytedance/seedream-4-5` | 2K-4K cinematic quality |
+| Seedream 4.0 | `bytedance/seedream-4-0` | High quality 2K-4K |
+| Seedream 3.0 | `bytedance/seedream-3-0-t2i` | Accurate text rendering |
+| Reve | `falai/reve` | Natural language editing, text rendering |
+| ImagineArt 1.5 Pro | `falai/imagine-art-1-5-pro-preview` | Ultra-high-fidelity 4K |
+| FLUX Klein 4B | `pruna/flux-klein-4b` | Ultra-cheap ($0.0001/image) |
+| Topaz Upscaler | `falai/topaz-image-upscaler` | Professional upscaling |
+
+## Browse All Image Apps
+
+```bash
+infsh app list --category image
+```
+
+## Examples
+
+### Text-to-Image with FLUX
+
+```bash
+infsh app run falai/flux-dev-lora --input '{
+  "prompt": "professional product photo of a coffee mug, studio lighting"
+}'
+```
+
+### Fast Generation with FLUX Klein
+
+```bash
+infsh app run falai/flux-2-klein-lora --input '{"prompt": "sunset over mountains"}'
+```
+
+### Google Gemini 3 Pro
+
+```bash
+infsh app run google/gemini-3-pro-image-preview --input '{
+  "prompt": "photorealistic landscape with mountains and lake"
+}'
+```
+
+### Grok Imagine
+
+```bash
+infsh app run xai/grok-imagine-image --input '{
+  "prompt": "cyberpunk city at night",
+  "aspect_ratio": "16:9"
+}'
+```
+
+### Reve (with Text Rendering)
+
+```bash
+infsh app run falai/reve --input '{
+  "prompt": "A poster that says HELLO WORLD in bold letters"
+}'
+```
+
+### Seedream 4.5 (4K Quality)
+
+```bash
+infsh app run bytedance/seedream-4-5 --input '{
+  "prompt": "cinematic portrait of a woman, golden hour lighting"
+}'
+```
+
+### Image Upscaling
+
+```bash
+infsh app run falai/topaz-image-upscaler --input '{"image_url": "https://..."}'
+```
+
+### Stitch Multiple Images
+
+```bash
+infsh app run infsh/stitch-images --input '{
+  "images": ["https://img1.jpg", "https://img2.jpg"],
+  "direction": "horizontal"
+}'
+```
+
+## Related Skills
+
+```bash
+# Full platform skill (all 150+ apps)
+npx skills add inference-sh/skills@infsh-cli
+
+# Pruna P-Image (fast & economical)
+npx skills add inference-sh/skills@p-image
+
+# FLUX-specific skill
+npx skills add inference-sh/skills@flux-image
+
+# Upscaling & enhancement
+npx skills add inference-sh/skills@image-upscaling
+
+# Background removal
+npx skills add inference-sh/skills@background-removal
+
+# Video generation
+npx skills add inference-sh/skills@ai-video-generation
+
+# AI avatars from images
+npx skills add inference-sh/skills@ai-avatar-video
+```
+
+Browse all apps: `infsh app list`
+
+## Documentation
+
+- [Running Apps](https://inference.sh/docs/apps/running) - How to run apps via CLI
+- [Image Generation Example](https://inference.sh/docs/examples/image-generation) - Complete image generation guide
+- [Apps Overview](https://inference.sh/docs/apps/overview) - Understanding the app ecosystem
+