mindforge-cc 8.1.1 → 8.2.0

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/shard-helper.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+
+/**
+ * MindForge Shard Helper
+ * Automates SRD scoring and Semantic Retrieval for Tri-Tier Memory.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+// ── SRD Scoring Logic ────────────────────────────────────────────────────────
+
+function calculateSRD(item, recentReferences = []) {
+  // D (Decisiveness): 1.0 for terminal decisions, 0.5 for discoveries
+  let D = 0.5;
+  if (item.type === 'architectural_decision' || item.id && item.id.startsWith('ADR-')) D = 1.0;
+  
+  // F (Frequency): Normalized count of references
+  const refCount = recentReferences.filter(r => r === item.id || r === item.topic).length;
+  let F = Math.min(1.0, refCount / 5);
+
+  // I (Impact): Qualitative weight
+  let I = 0.5;
+  const highImpactKeywords = ['security', 'auth', 'database', 'kafka', 'core', 'protocol'];
+  const text = (item.content || '' + item.topic || '').toLowerCase();
+  if (highImpactKeywords.some(k => text.includes(k))) I = 1.0;
+  if (text.includes('typo') || text.includes('comment') || text.includes('housekeeping')) I = 0.1;
+
+  return (D * 0.6) + (F * 0.1) + (I * 0.3);
+}
+
+// ── Semantic Retrieval Logic ──────────────────────────────────────────────────
+
+function getRelevanceScore(query, text) {
+  const queryWords = query.toLowerCase().split(/\W+/).filter(w => w.length > 3);
+  const targetText = text.toLowerCase();
+  let score = 0;
+  
+  queryWords.forEach(word => {
+    if (targetText.includes(word)) score += 1;
+  });
+  
+  return score;
+}
+
+// ── CLI Handlers ─────────────────────────────────────────────────────────────
+
+if (command === '--analyse') {
+  const inputFile = args[1] || '.planning/HANDOFF.json';
+  if (!fs.existsSync(inputFile)) {
+    console.error(`Error: ${inputFile} not found.`);
+    process.exit(1);
+  }
+
+  const data = JSON.parse(fs.readFileSync(inputFile, 'utf8'));
+  const items = data.hot_context ? 
+    [...(data.hot_context.active_decisions || []), ...(data.hot_context.recent_discoveries || [])] :
+    [];
+
+  const scored = items.map(item => {
+    const score = calculateSRD(item);
+    const content = JSON.stringify(item);
+    const checksum = crypto.createHash('sha256').update(content).digest('hex');
+    
+    return {
+      ...item,
+      srd: score,
+      checksum,
+      tags: [...(item.tags || []), ...(item.topic ? item.topic.toLowerCase().split(' ') : [])]
+    };
+  }).sort((a, b) => b.srd - a.srd);
+
+  console.log(JSON.stringify(scored, null, 2));
+} 
+
+else if (command === '--verify') {
+  const shardPath = args[1];
+  const lines = fs.readFileSync(shardPath, 'utf8').split('\n').filter(l => l.trim());
+  let issues = [];
+
+  lines.forEach((line, idx) => {
+    const item = JSON.parse(line);
+    const storedChecksum = item.checksum;
+    delete item.checksum;
+    delete item.srd;
+    delete item.tags;
+    
+    const currentChecksum = crypto.createHash('sha256').update(JSON.stringify(item)).digest('hex');
+    if (storedChecksum !== currentChecksum) {
+      issues.push(`Line ${idx + 1}: Checksum mismatch!`);
+    }
+  });
+
+  if (issues.length > 0) {
+    console.error(`Verification FAILED:\n${issues.join('\n')}`);
+    process.exit(1);
+  }
+  console.log('Shard integrity verified.');
+}
+
+else if (command === '--retrieve') {
+  const query = args[1];
+  const shardDir = '.planning/memories/';
+  
+  if (!fs.existsSync(shardDir)) {
+    console.log('[]');
+    process.exit(0);
+  }
+
+  const shards = fs.readdirSync(shardDir).filter(f => f.endsWith('.jsonl'));
+  let results = [];
+
+  shards.forEach(shard => {
+    const lines = fs.readFileSync(path.join(shardDir, shard), 'utf8').split('\n').filter(l => l.trim());
+    lines.forEach(line => {
+      const item = JSON.parse(line);
+      const score = getRelevanceScore(query, (item.content || '') + ' ' + (item.topic || ''));
+      if (score > 0) {
+        results.push({ ...item, retrieval_score: score });
+      }
+    });
+  });
+
+  results.sort((a, b) => b.retrieval_score - a.retrieval_score);
+  console.log(JSON.stringify(results.slice(0, 3), null, 2));
+}
+
+else {
+  console.log('Usage: shard-helper --analyse [file] | --retrieve "[query]"');
+}

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/skill-registry.js

@@ -0,0 +1,232 @@
+#!/usr/bin/env node
+/**
+ * MindForge Skill Registry — v1.0.0
+ * Handles manifest updates, skill copying, and audit logging.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const ARGS = process.argv.slice(2);
+let ACTION = ARGS[0]; // install | register | audit
+
+function main() {
+  if (!ACTION || ARGS.includes('--help') || ARGS.includes('-h')) {
+    console.log('\nUsage: mindforge-cc <install-skill|register-skill|audit-skill> [args]\n');
+    process.exit(0);
+  }
+
+  // Handle cases where the action might be missing if called incorrectly
+  const validActions = ['install', 'register', 'audit', 'sign'];
+  if (!validActions.includes(ACTION)) {
+    console.error(`❌ Invalid or missing action: ${ACTION}`);
+    console.error(`   Expected one of: ${validActions.join(', ')}`);
+    process.exit(1);
+  }
+
+  switch (ACTION) {
+    case 'install':
+      handleInstall();
+      break;
+    case 'register':
+      handleRegister();
+      break;
+    case 'audit':
+      handleAudit();
+      break;
+    case 'sign':
+      handleSign();
+      break;
+    default:
+      console.error(`❌ Unknown action: ${ACTION}`);
+      process.exit(1);
+  }
+}
+
+async function handleSign() {
+  const skillName = ARGS[1];
+  const ztai = require('./governance/ztai-manager');
+  const crypto = require('node:crypto');
+
+  if (!skillName) {
+    console.error('❌ Missing skill name to sign');
+    process.exit(1);
+  }
+
+  // Find the skill file
+  const bases = [
+    '.mindforge/skills',
+    '.mindforge/org/skills',
+    '.mindforge/project-skills'
+  ];
+  
+  let targetPath = null;
+  for (const base of bases) {
+    const p = path.join(process.cwd(), base, skillName, 'SKILL.md');
+    if (fs.existsSync(p)) {
+      targetPath = p;
+      break;
+    }
+  }
+
+  if (!targetPath) {
+    console.error(`❌ Skill ${skillName} not found in any registry path.`);
+    process.exit(1);
+  }
+
+  console.log(`🛡️  Signing skill: ${skillName}...`);
+  const content = fs.readFileSync(targetPath, 'utf8');
+  const hash = crypto.createHash('sha256').update(content).digest('hex');
+
+  try {
+    // We use a dedicated System DID for skill signing (Tier 3)
+    const systemDid = await ztai.registerAgent('MindForge-System-Secretary', 3);
+    const signature = await ztai.signData(systemDid, hash);
+
+    const sigPath = path.join(process.cwd(), '.mindforge', 'org', 'skills', 'SIGNATURES.json');
+    let signatures = {};
+    if (fs.existsSync(sigPath)) {
+      signatures = JSON.parse(fs.readFileSync(sigPath, 'utf8'));
+    }
+
+    signatures[skillName] = {
+      hash,
+      signature,
+      did: systemDid,
+      timestamp: new Date().toISOString()
+    };
+
+    fs.writeFileSync(sigPath, JSON.stringify(signatures, null, 2));
+    console.log(`✅ Skill ${skillName} signed and registered in SIGNATURES.json`);
+    process.exit(0);
+  } catch (err) {
+    console.error(`❌ Signing failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+function handleInstall() {
+  const skillName = ARGS[1];
+  const tierFlag = ARGS.indexOf('--tier');
+  const tier = tierFlag !== -1 ? ARGS[tierFlag + 1] : '2';
+
+  if (!skillName) {
+    console.error('❌ Missing skill name');
+    process.exit(1);
+  }
+
+  console.log(`🚀 Installing skill: ${skillName} (Tier ${tier})...`);
+
+  // Target directory logic
+  let targetBase = '.mindforge/org/skills';
+  if (tier === '1') targetBase = '.mindforge/skills';
+  if (tier === '3') targetBase = '.mindforge/project-skills';
+
+  const targetDir = path.join(process.cwd(), targetBase, skillName);
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+
+  // Mock behavior for Day 3/4 testing if no real registry
+  // Expect source to be in examples/ if it exists, otherwise just touch it
+  const mockSrc = path.join(process.cwd(), 'examples', 'skills', `${skillName}.md`);
+  const targetFile = path.join(targetDir, 'SKILL.md');
+
+  if (fs.existsSync(mockSrc)) {
+    fs.copyFileSync(mockSrc, targetFile);
+    console.log(`  ✅ Copied from ${mockSrc}`);
+  } else {
+    // If no source, we look for it in the current dir for the agentic flow
+    const localSrc = path.join(process.cwd(), 'SKILL.md');
+    if (fs.existsSync(localSrc)) {
+       fs.copyFileSync(localSrc, targetFile);
+       console.log('  ✅ Copied from local SKILL.md');
+    } else {
+       // Just create a placeholder for testing if nothing else
+       fs.writeFileSync(targetFile, `---\nname: ${skillName}\nversion: 1.0.0\nstatus: alpha\ntriggers: test, mock, placeholder\n---\n# ${skillName}\nPlaceholder for ${skillName} skill.\n`);
+       console.log('  ⚠️  Created mock SKILL.md (no source found)');
+    }
+  }
+
+  process.exit(0);
+}
+
+function handleRegister() {
+  const skillName = ARGS[1];
+  const version = ARGS[2] || '1.0.0';
+  const tier = ARGS[3] || '2';
+
+  const manifestPath = path.join(process.cwd(), '.mindforge', 'org', 'skills', 'MANIFEST.md');
+  if (!fs.existsSync(manifestPath)) {
+    console.error('❌ MANIFEST.md not found');
+    process.exit(1);
+  }
+
+  let content = fs.readFileSync(manifestPath, 'utf8');
+  
+  // Find the tier section (e.g., ## Org Skills)
+  const tierHeaders = {
+    '1': '## Core Skills',
+    '2': '## Org Skills',
+    '3': '## Project Skills'
+  };
+  const header = tierHeaders[tier];
+  
+  if (!content.includes(header)) {
+    console.error(`❌ Tier header ${header} not found in manifest`);
+    process.exit(1);
+  }
+
+  // Build the row: | Name | Version | Status | Min MindForge | Path |
+  const skillPath = tier === '1' ? `.mindforge/skills/${skillName}/SKILL.md` :
+                   tier === '2' ? `.mindforge/org/skills/${skillName}/SKILL.md` :
+                   `.mindforge/project-skills/${skillName}/SKILL.md`;
+
+  const newRow = `| ${skillName} | ${version} | stable | 0.1.0 | ${skillPath} |`;
+  
+  // Check if already registered
+  if (content.includes(`| ${skillName} |`)) {
+    console.log(`  ⏭️  ${skillName} already registered, updating version...`);
+    content = content.replace(new RegExp(`\\| ${skillName} \\| .* \\|`), `| ${skillName} | ${version} | stable | 0.1.0 | ${skillPath} |`);
+  } else {
+    // Insert after the table header row in that section
+    const sectionIndex = content.indexOf(header);
+    const tableHeaderIndex = content.indexOf('|---|', sectionIndex);
+    const endOfHeaderRow = content.indexOf('\n', tableHeaderIndex) + 1;
+    
+    content = content.slice(0, endOfHeaderRow) + newRow + '\n' + content.slice(endOfHeaderRow);
+    console.log(`  ✅ Registered ${skillName} in ${header}`);
+  }
+
+  fs.writeFileSync(manifestPath, content, 'utf8');
+  process.exit(0);
+}
+
+function handleAudit() {
+  const skillName = ARGS[1];
+  const version = ARGS[2];
+  const tier = ARGS[3];
+  
+  const auditPath = path.join(process.cwd(), '.planning', 'AUDIT.jsonl');
+  if (!fs.existsSync(path.dirname(auditPath))) {
+    fs.mkdirSync(path.dirname(auditPath), { recursive: true });
+  }
+
+  const entry = {
+    timestamp: new Date().toISOString(),
+    event: 'skill_installed',
+    skill_name: skillName,
+    skill_version: version,
+    tier: parseInt(tier, 10),
+    source: 'cli-system',
+    validation_passed: true
+  };
+
+  fs.appendFileSync(auditPath, JSON.stringify(entry) + '\n', 'utf8');
+  console.log(`  📝 Audit entry written for ${skillName}`);
+  process.exit(0);
+}
+
+main();

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/skill-validator.js

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+/**
+ * MindForge Skill Validator — v1.0.0
+ * Validates SKILL.md files against schema and content requirements.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const ARGS = process.argv.slice(2);
+const NO_COLOR = ARGS.includes('--no-color');
+
+const colors = {
+  reset:  NO_COLOR ? '' : '\x1b[0m',
+  red:    NO_COLOR ? '' : '\x1b[31m',
+  green:  NO_COLOR ? '' : '\x1b[32m',
+  yellow: NO_COLOR ? '' : '\x1b[33m',
+  cyan:   NO_COLOR ? '' : '\x1b[36m',
+  bold:   NO_COLOR ? '' : '\x1b[1m'
+};
+
+function main() {
+  const target = ARGS[0];
+  if (!target || ARGS.includes('--help') || ARGS.includes('-h')) {
+    console.log('\nUsage: mindforge-cc validate-skill <path-to-SKILL.md>\n');
+    process.exit(0);
+  }
+
+  const filePath = path.resolve(process.cwd(), target);
+  if (!fs.existsSync(filePath)) {
+    console.error(`${colors.red}❌ File not found: ${filePath}${colors.reset}`);
+    process.exit(1);
+  }
+
+  console.log(`\n${colors.bold}MindForge Skill Validator — ${path.basename(filePath)}${colors.reset}`);
+  console.log('─'.repeat(60));
+
+  const content = fs.readFileSync(filePath, 'utf8');
+  const results = { schema: [], content: [], quality: [], valid: true, attestation: { ok: true, msg: 'No signature found (optional)' } };
+
+  // ── Level 0: Binary Runtime Attestation (v5 Pillar IV) ──────────────────────
+  const sigPath = path.join(process.cwd(), '.mindforge', 'org', 'skills', 'SIGNATURES.json');
+  if (fs.existsSync(sigPath)) {
+    const crypto = require('node:crypto');
+    const ztai = require('./governance/ztai-manager');
+    const signatures = JSON.parse(fs.readFileSync(sigPath, 'utf8'));
+    const skillNameCandidate = path.basename(path.dirname(filePath));
+    const sigRecord = signatures[skillNameCandidate];
+
+    if (sigRecord) {
+      const currentHash = crypto.createHash('sha256').update(content).digest('hex');
+      const isHashValid = currentHash === sigRecord.hash;
+      const isSigValid = ztai.verifySignature(sigRecord.did, currentHash, sigRecord.signature);
+
+      if (!isHashValid || !isSigValid) {
+        results.attestation = { ok: false, msg: `INTEGRITY FAILURE: Signature mismatch [Hash: ${isHashValid}, Sig: ${isSigValid}]` };
+        results.valid = false;
+      } else {
+        results.attestation = { ok: true, msg: `VERIFIED: Signed by ${sigRecord.did}` };
+      }
+    } else if (ARGS.includes('--enterprise')) {
+      results.attestation = { ok: false, msg: 'REQUIRED: No signature found for this skill in Enterprise Mode' };
+      results.valid = false;
+    }
+  }
+
+  // ── Level 1: Schema ─────────────────────────────────────────────────────────
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!fmMatch) {
+    results.schema.push({ ok: false, msg: 'Missing frontmatter (--- delimiters)' });
+    results.valid = false;
+  } else {
+    results.schema.push({ ok: true, msg: 'Frontmatter delimiters present' });
+    const fmLines = fmMatch[1].split('\n');
+    const fm = {};
+    fmLines.forEach(line => {
+      const parts = line.split(':');
+      if (parts.length >= 2) fm[parts[0].trim()] = parts.slice(1).join(':').trim();
+    });
+
+    // name
+    if (!fm.name) {
+      results.schema.push({ ok: false, msg: 'Missing field: name' });
+      results.valid = false;
+    } else if (!/^[a-z][a-z0-9-]+$/.test(fm.name)) {
+      results.schema.push({ ok: false, msg: `Invalid name format: ${fm.name} (must be kebab-case)` });
+      results.valid = false;
+    } else {
+      results.schema.push({ ok: true, msg: `name: ${fm.name}` });
+    }
+
+    // version
+    if (!fm.version) {
+      results.schema.push({ ok: false, msg: 'Missing field: version' });
+      results.valid = false;
+    } else if (!/^\d+\.\d+\.\d+$/.test(fm.version)) {
+      results.schema.push({ ok: false, msg: `Invalid version: ${fm.version} (must be x.y.z)` });
+      results.valid = false;
+    } else {
+      results.schema.push({ ok: true, msg: `version: ${fm.version}` });
+    }
+
+    // status
+    const validStatuses = ['stable', 'beta', 'alpha', 'deprecated'];
+    if (!fm.status || !validStatuses.includes(fm.status)) {
+      results.schema.push({ ok: false, msg: `Invalid status: ${fm.status}` });
+      results.valid = false;
+    } else {
+      results.schema.push({ ok: true, msg: `status: ${fm.status}` });
+    }
+
+    // triggers
+    if (!fm.triggers) {
+      results.schema.push({ ok: false, msg: 'Missing field: triggers' });
+      results.valid = false;
+    } else {
+      const triggers = fm.triggers.split(',').map(t => t.trim()).filter(Boolean);
+      if (triggers.length < 5) {
+        results.schema.push({ ok: false, msg: `Too few triggers: ${triggers.length} (min: 5)` });
+        results.valid = false;
+      } else {
+        results.schema.push({ ok: true, msg: `triggers: ${triggers.length} keywords` });
+      }
+    }
+  }
+
+  // ── Level 2: Content ────────────────────────────────────────────────────────
+  results.content.push({
+    id: 'size',
+    ok: content.length >= 1024 && content.length <= 200 * 1024,
+    weight: 0.1,
+    msg: `File size: ${(content.length / 1024).toFixed(1)}KB (1KB-200KB)`
+  });
+
+  results.content.push({
+    id: 'actions',
+    ok: /##\s+(Mandatory actions|When this skill is active)/i.test(content),
+    weight: 0.2,
+    msg: 'Mandatory actions section present'
+  });
+
+  results.content.push({
+    id: 'checklist',
+    ok: /- \[ \]/.test(content),
+    weight: 0.1,
+    msg: 'Self-check/checklist items found'
+  });
+
+  results.content.push({
+    id: 'security',
+    ok: !/IGNORE ALL PREVIOUS/i.test(content),
+    weight: 0.2,
+    msg: 'No injection patterns detected'
+  });
+
+  // ── Level 3: Quality (v5 7-Dimension Scoring) ───────────────────────────────
+  const dimensions = [
+    { id: 'schema', weight: 0.15, ok: results.schema.every(r => r.ok), name: 'Schema Compliance' },
+    { id: 'triggers', weight: 0.15, ok: results.schema.some(r => r.msg.includes('triggers') && r.ok), name: 'Trigger Density' },
+    { id: 'actions', weight: 0.20, ok: results.content.some(r => r.id === 'actions' && r.ok), name: 'Mandatory Coverage' },
+    { id: 'security', weight: 0.20, ok: results.content.some(r => r.id === 'security' && r.ok), name: 'Security Sanitization' },
+    { id: 'clarity', weight: 0.10, ok: content.split('\n').length > 50, name: 'Doc Clarity' },
+    { id: 'edges', weight: 0.10, ok: /edge cases|error handling/i.test(content), name: 'Edge Case Handling' },
+    { id: 'examples', weight: 0.10, ok: /example|Usage/i.test(content), name: 'Example Fidelity' }
+  ];
+
+  let totalScore = 0;
+  dimensions.forEach(d => {
+    if (d.ok) totalScore += d.weight * 10;
+  });
+
+  results.certificationScore = parseFloat(totalScore.toFixed(1));
+
+  // ── Output ──────────────────────────────────────────────────────────────────
+  console.log(`${colors.cyan}${colors.bold}Schema validation:${colors.reset}`);
+  results.schema.forEach(r => console.log(`  ${r.ok ? colors.green + '✅' : colors.red + '❌'} ${r.msg}`));
+
+  console.log(`\n${colors.cyan}${colors.bold}Content validation:${colors.reset}`);
+  results.content.forEach(r => {
+    if (!r.ok) results.valid = false;
+    console.log(`  ${r.ok ? colors.green + '✅' : colors.red + '❌'} ${r.msg}`);
+  });
+
+  console.log(`\n${colors.cyan}${colors.bold}Enterprise Certification (7D):${colors.reset}`);
+  dimensions.forEach(d => {
+    console.log(`  ${d.ok ? colors.green + '✅' : colors.red + '❌'} ${d.name.padEnd(25)} [Weight: ${(d.weight * 100).toFixed(0)}%]`);
+  });
+  
+  const scoreColor = results.certificationScore >= 7.0 ? colors.green : colors.yellow;
+  console.log(`\n  ${colors.bold}Certification Score: ${scoreColor}${results.certificationScore}/10.0${colors.reset}`);
+
+  console.log('─'.repeat(60));
+
+  const isEnterprise = ARGS.includes('--enterprise');
+  if (isEnterprise && results.certificationScore < 7.0) {
+    console.error(`${colors.red}❌ FAILURE: Skill does not meet the minimum Enterprise Certification Score (7.0).${colors.reset}`);
+    results.valid = false;
+  }
+
+  if (results.valid) {
+    console.log(`${colors.green}${colors.bold}Result: VALID${colors.reset}`);
+    process.exit(0);
+  } else {
+    console.log(`${colors.red}${colors.bold}Result: INVALID${colors.reset}`);
+    process.exit(1);
+  }
+}
+
+main();

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/skills-builder/learn-cli.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+/**
+ * MindForge v2 — Learn Skill CLI
+ * Ingests content from a source and generates a validated SKILL.md.
+ */
+'use strict';
+
+const Loader    = require('./source-loader');
+const Generator = require('./skill-generator');
+const Scorer    = require('./skill-scorer');
+const Registrar = require('./skill-registrar');
+
+const ARGS = process.argv.slice(2);
+const SOURCE = ARGS[0];
+const NAME   = ARGS[1] || 'new-skill';
+
+if (!SOURCE) {
+  console.log('Usage: node bin/skills-builder/learn-cli.js <source-url-or-path> [skill-name]');
+  process.exit(1);
+}
+
+async function main() {
+  try {
+    console.log(`\n📚 Learning skill: ${NAME} from ${SOURCE}`);
+    
+    // 1. Load
+    const { content, metadata } = await Loader.load(SOURCE);
+    
+    // 2. Generate
+    const result = await Generator.generate({
+      skillName: NAME,
+      content,
+      sourceMetadata: metadata,
+      sessionId: 'cli-learn'
+    });
+    
+    // 3. Score
+    const scoreResult = Scorer.score(result.skillPath);
+    console.log(`\n✅ Skill generated: ${result.skillPath}`);
+    console.log(`⭐ Quality Score: ${scoreResult.quality_score}/100 (${scoreResult.threshold_status})`);
+    
+    // 4. Register if acceptable
+    if (scoreResult.can_register) {
+      Registrar.register(result.skillPath, 'project');
+      console.log('📝 Registered in MANIFEST.md');
+    } else {
+      console.log('⚠️ Score too low for automatic registration.');
+      scoreResult.improvement_suggestions.forEach(s => console.log(`  - ${s}`));
+    }
+    
+  } catch (err) {
+    console.error(`\n❌ Error: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/skills-builder/marketplace-cli.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+/**
+ * MindForge v2 — Marketplace CLI
+ * Searched and manages community skills via npm registry.
+ */
+'use strict';
+
+const Marketplace = require('./marketplace-client');
+
+const ARGS = process.argv.slice(2);
+const CMD  = ARGS[0];
+const QUERY = ARGS[1];
+
+if (!CMD) {
+  console.log('Usage: node bin/skills-builder/marketplace-cli.js <search|featured|trending|install> [query]');
+  process.exit(1);
+}
+
+async function main() {
+  try {
+    switch (CMD) {
+      case 'search':
+        const results = await Marketplace.search(QUERY);
+        console.table(results.map(r => ({
+          name: r.name,
+          version: r.version,
+          score: r.quality?.score || 'N/A',
+          description: r.description.slice(0, 50) + '...'
+        })));
+        break;
+        
+      case 'featured':
+      case 'trending':
+        const list = await Marketplace.getFeatured();
+        console.table(list);
+        break;
+        
+      case 'install':
+        if (!QUERY) throw new Error('Package name required for install');
+        await Marketplace.install(QUERY);
+        console.log(`✅ Successfully installed ${QUERY}`);
+        break;
+
+      default:
+        console.error(`Unknown command: ${CMD}`);
+        process.exit(1);
+    }
+  } catch (err) {
+    console.error(`\n❌ Error: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+main();