mindforge-cc 10.7.0 → 11.2.0

package/bin/security/trust-boundaries.js

@@ -0,0 +1,102 @@
+'use strict';
+
+const crypto = require('crypto');
+
+/**
+ * Recursively sorts object keys for deterministic JSON serialization.
+ * Arrays are preserved in order; nested objects get sorted keys.
+ */
+function stableStringify(value) {
+  if (value === null || typeof value !== 'object') {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return '[' + value.map(item => stableStringify(item)).join(',') + ']';
+  }
+  const sortedKeys = Object.keys(value).sort();
+  const pairs = sortedKeys.map(key => {
+    return JSON.stringify(key) + ':' + stableStringify(value[key]);
+  });
+  return '{' + pairs.join(',') + '}';
+}
+
+/**
+ * Computes SHA-256 hash of a manifest using stable key-sorted serialization.
+ * Returns { name, hash, pinnedAt }.
+ */
+function pinManifest(manifest) {
+  const serialized = stableStringify(manifest);
+  const hash = crypto.createHash('sha256').update(serialized).digest('hex');
+  return {
+    name: manifest.name,
+    hash,
+    pinnedAt: Date.now()
+  };
+}
+
+/**
+ * Verifies a manifest against a previously pinned hash.
+ * Returns { valid: true } or { valid: false, reason }.
+ */
+function verifyManifest(manifest, pin) {
+  const serialized = stableStringify(manifest);
+  const computed = crypto.createHash('sha256').update(serialized).digest('hex');
+  if (computed === pin.hash) {
+    return { valid: true };
+  }
+  return {
+    valid: false,
+    reason: `hash mismatch: expected ${pin.hash}, got ${computed}`
+  };
+}
+
+/**
+ * Wraps content with untrusted provenance metadata.
+ * Returns { content, trusted: false, provenance: { source, tool, timestamp } }.
+ */
+function tagUntrusted(content, meta) {
+  return {
+    content,
+    trusted: false,
+    provenance: {
+      source: meta.source,
+      tool: meta.tool,
+      timestamp: Date.now()
+    }
+  };
+}
+
+// Null byte (char code 0). Built via fromCharCode so we never embed a control
+// character in a regex literal (eslint no-control-regex).
+const NUL = String.fromCharCode(0);
+
+/**
+ * Detects high-impact / destructive commands via case-insensitive pattern matching.
+ * Returns true if the command matches known destructive patterns.
+ */
+function isHighImpact(command) {
+  // Strip null bytes first — shells ignore them, so an attacker must not be
+  // able to use a NUL to split a destructive token and slip past the patterns.
+  const sanitized = String(command).split(NUL).join('');
+  const patterns = [
+    /rm\s+(-\w*r\w*\s+-\w*f|(-\w*f\w*\s+-\w*r)|-\w*rf|-\w*fr)/i,
+    /git\s+push\s+.*--force/i,
+    /git\s+push\s+.*-f/i,
+    /drop\s+(table|database)/i,
+    /git\s+reset\s+--hard/i,
+    /delete\s+from/i,
+    /truncate\s+table/i,
+    /\bmkfs(\.\w+)?\s+\/dev\//i,
+    /\bdd\b.*\bof=\/dev\//i,
+    /\b(curl|wget)\b.*\|\s*(bash|sh|zsh)\b/i,
+    /^\s*find\s+.*-delete\b/i,
+  ];
+  return patterns.some(pattern => pattern.test(sanitized));
+}
+
+module.exports = {
+  pinManifest,
+  verifyManifest,
+  tagUntrusted,
+  isHighImpact
+};

package/bin/security/trust-gate-hook.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+'use strict';
+
+const { isHighImpact } = require('./trust-boundaries');
+
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => { input += chunk; });
+process.stdin.on('end', () => {
+  try {
+    const event = JSON.parse(input);
+
+    // Only gate Bash tool calls
+    if (event.tool_name !== 'Bash') {
+      process.exit(0); // allow
+    }
+
+    const fullCommand = event.tool_input?.command || '';
+    const command = fullCommand.split('\n')[0];
+
+    if (isHighImpact(command)) {
+      // Output a block reason (Claude Code shows this to the user)
+      process.stdout.write(JSON.stringify({
+        decision: 'block',
+        reason: `[TrustGate] High-impact command detected: "${command.substring(0, 80)}..." — requires explicit user approval`
+      }));
+      process.exit(2); // block
+    }
+
+    process.exit(0); // allow
+  } catch (e) {
+    process.stderr.write('[trust-gate-hook] parse error (BLOCKING): ' + e.message + '\n');
+    process.stdout.write(JSON.stringify({
+      decision: 'block',
+      reason: '[TrustGate] Could not verify command safety — parse error'
+    }));
+    process.exit(2);
+  }
+});

package/bin/skill-registry.js

@@ -215,7 +215,6 @@ function handleAudit() {
   }
 
   const entry = {
-    timestamp: new Date().toISOString(),
     event: 'skill_installed',
     skill_name: skillName,
     skill_version: version,
@@ -224,7 +223,9 @@ function handleAudit() {
     validation_passed: true
   };
 
-  fs.appendFileSync(auditPath, JSON.stringify(entry) + '\n', 'utf8');
+  // UC-04b: unified, hash-chained, durable append into the single verifiable chain.
+  const { appendAuditEntrySync } = require('./autonomous/audit-writer');
+  appendAuditEntrySync(auditPath, entry);
   console.log(`  📝 Audit entry written for ${skillName}`);
   process.exit(0);
 }

package/bin/skills-builder/marketplace-cli.js

@@ -19,7 +19,7 @@ if (!CMD) {
 async function main() {
   try {
     switch (CMD) {
-      case 'search':
+      case 'search': {
         const results = await Marketplace.search(QUERY);
         console.table(results.map(r => ({
           name: r.name,
@@ -28,12 +28,14 @@ async function main() {
           description: r.description.slice(0, 50) + '...'
         })));
         break;
-        
+      }
+
       case 'featured':
-      case 'trending':
+      case 'trending': {
         const list = await Marketplace.getFeatured();
         console.table(list);
         break;
+      }
         
       case 'install':
         if (!QUERY) throw new Error('Package name required for install');

package/bin/skills-builder/skill-registrar.js

@@ -82,11 +82,10 @@ function register(params) {
     );
   }
 
-  // Write AUDIT entry
+  // Write AUDIT entry via the unified, hash-chained, durable append (UC-04b).
   if (fs.existsSync(path.dirname(AUDIT_PATH))) {
-    const entry = {
-      id:            require('crypto').randomBytes(8).toString('hex'),
-      timestamp:     new Date().toISOString(),
+    const { appendAuditEntrySync } = require('../autonomous/audit-writer');
+    appendAuditEntrySync(AUDIT_PATH, {
       event:         'skill_learned',
       agent:         'mindforge-skills-builder',
       phase:         null,
@@ -97,8 +96,7 @@ function register(params) {
       source_type:   sourceType,
       source:        String(source).slice(0, 200),
       skill_path:    relativePath,
-    };
-    fs.appendFileSync(AUDIT_PATH, JSON.stringify(entry) + '\n');
+    });
   }
 
   return { registered: true, skillName, tier, qualityScore };

package/bin/sre/sentinel.js

@@ -109,13 +109,15 @@ class Sentinel {
   }
 
   logToAudit(event, targetPath) {
-    const logEntry = {
-      id: crypto.randomBytes(8).toString('hex'),
-      timestamp: new Date().toISOString(),
+    // UC-04b: route through the unified, hash-chained, durable append so Sentinel's
+    // incident entries link into the single verifiable chain (was a raw appendFileSync
+    // that broke the chain). appendAuditEntrySync caches the chain head per resolved
+    // path, so an explicit targetPath is chained correctly too.
+    const { appendAuditEntrySync } = require('../autonomous/audit-writer');
+    appendAuditEntrySync(targetPath || this.auditPath, {
       agent: 'mindforge-sentinel',
       ...event
-    };
-    fs.appendFileSync(targetPath || this.auditPath, JSON.stringify(logEntry) + '\n');
+    });
   }
 
   stop() {

package/bin/utils/append-queue.js

@@ -0,0 +1,55 @@
+'use strict';
+/**
+ * MindForge — Single-writer serialized append queue (UC-09).
+ * Guarantees: (1) appends to a given file are serialized (no interleaving across
+ * concurrent callers in this process), (2) each append() resolves only after the
+ * bytes are fsync'd to disk (durability), (3) a trailing newline delimits records.
+ *
+ * Scope: protects against in-process concurrent-write interleaving and crash-loss
+ * of acknowledged writes. Cross-PROCESS locking is out of scope for the
+ * single-operator localhost model (documented; revisit if multi-process writers appear).
+ */
+const fs = require('fs');
+
+// path -> Promise chain tail. NOTE: this is intended for a small, fixed set of
+// known paths (e.g. AUDIT.jsonl). Per-path entries are NEVER evicted, so do NOT
+// key this by high-cardinality dynamic paths — doing so would leak memory
+// unboundedly. Revisit with an LRU/eviction policy if dynamic paths are needed.
+const queues = new Map();
+
+function createAppendQueue(filePath) {
+  if (!queues.has(filePath)) queues.set(filePath, Promise.resolve());
+
+  function append(line) {
+    const record = line.endsWith('\n') ? line : line + '\n';
+    const tail = queues.get(filePath).then(() => writeDurable(filePath, record));
+    queues.set(filePath, tail.catch(() => {}));
+    return tail;
+  }
+
+  function drain() {
+    return queues.get(filePath);
+  }
+
+  return Object.freeze({ append, drain });
+}
+
+function writeDurable(filePath, data) {
+  return new Promise((resolve, reject) => {
+    fs.open(filePath, 'a', (openErr, fd) => {
+      if (openErr) return reject(openErr);
+      fs.write(fd, data, (writeErr) => {
+        if (writeErr) { fs.close(fd, () => {}); return reject(writeErr); }
+        fs.fsync(fd, (syncErr) => {
+          fs.close(fd, (closeErr) => {
+            if (syncErr) return reject(syncErr);
+            if (closeErr) return reject(closeErr);
+            resolve();
+          });
+        });
+      });
+    });
+  });
+}
+
+module.exports = { createAppendQueue };

package/bin/utils/file-io.js

@@ -3,55 +3,46 @@
 const fs = require('fs');
 const fsp = require('fs/promises');
 const path = require('path');
-const crypto = require('crypto');
+const zlib = require('zlib');
 
+/**
+ * Hash-chained audit writer (class API preserved for nexus-tracer + policy-engine).
+ *
+ * UC-04b: this class previously maintained a SECOND, DIVERGENT chain implementation
+ * (it hashed {...entry, timestamp, previous_hash} — injecting timestamp into the
+ * material differently from the canonical writer), so entries it wrote could never
+ * verify against bin/governance/audit-verifier.js. It now delegates every write to
+ * the SINGLE shared `appendAuditEntrySync` (canonical hashAuditEntry, synchronous +
+ * fsync-durable), so there is ONE hasher and ONE on-disk chain per file.
+ *
+ * The async API (write/flush/close returning promises) is kept because callers do
+ * `await this._auditWriter.write(entry)`; the underlying append is now synchronous
+ * and durable, so flush()/close() are no-ops retained for API compatibility.
+ */
 class AuditWriter {
   constructor(filePath) {
     this._path = filePath;
-    this._buffer = [];
-    this._flushTimer = null;
+    // Retained for API compatibility; the unified append is synchronous so there
+    // is no longer an internal buffer or timer to manage.
     this._lastHash = null;
   }
 
-  write(entry) {
-    // Add Merkle chain link
-    const entryWithHash = {
-      ...entry,
-      timestamp: entry.timestamp || new Date().toISOString(),
-      previous_hash: this._lastHash
-    };
-    const serialized = JSON.stringify(entryWithHash);
-    this._lastHash = crypto.createHash('sha256').update(serialized).digest('hex');
-    entryWithHash._hash = this._lastHash;
-
-    this._buffer.push(JSON.stringify(entryWithHash));
-
-    if (this._buffer.length >= 10) {
-      return this.flush();
-    }
-    if (!this._flushTimer) {
-      this._flushTimer = setTimeout(() => this.flush(), 100);
-    }
-    return Promise.resolve();
+  async write(entry) {
+    // Lazy require to avoid a require-cycle: audit-writer.js requires this file
+    // (AuditRotator) at load time, so we cannot require it at module top level.
+    const { appendAuditEntrySync } = require('../autonomous/audit-writer');
+    const chained = appendAuditEntrySync(this._path, entry);
+    this._lastHash = chained._hash;
+    return chained;
   }
 
-  async flush() {
-    if (this._buffer.length === 0) return;
-    clearTimeout(this._flushTimer);
-    this._flushTimer = null;
-
-    const lines = this._buffer.splice(0);
-    const content = lines.join('\n') + '\n';
+  async flush() { /* no-op: appendAuditEntrySync is synchronous + fsync-durable */ }
 
-    await fsp.mkdir(path.dirname(this._path), { recursive: true });
-    await fsp.appendFile(this._path, content);
-  }
-
-  async close() {
-    await this.flush();
-  }
+  async close() { /* no-op: nothing buffered */ }
 
   async initLastHash() {
+    // The unified append seeds its own chain head from the file tail; this remains
+    // for callers that expect to prime _lastHash explicitly.
     try {
       const content = await fsp.readFile(this._path, 'utf8');
       const lines = content.trim().split('\n').filter(Boolean);
@@ -99,4 +90,65 @@ function readJSONSync(filePath) {
   }
 }
 
-module.exports = { AuditWriter, readJSON, writeJSON, readJSONL, readJSONSync };
+function atomicWriteJSON(filePath, data) {
+  const tmpPath = filePath + '.tmp.' + process.pid;
+  const content = JSON.stringify(data, null, 2) + '\n';
+  const fd = fs.openSync(tmpPath, 'w');
+  fs.writeSync(fd, content);
+  fs.fsyncSync(fd);
+  fs.closeSync(fd);
+  fs.renameSync(tmpPath, filePath);
+}
+
+async function atomicWriteJSONAsync(filePath, data) {
+  const tmpPath = filePath + '.tmp.' + process.pid;
+  const content = JSON.stringify(data, null, 2) + '\n';
+  const fh = await fsp.open(tmpPath, 'w');
+  await fh.write(content);
+  await fh.sync();
+  await fh.close();
+  await fsp.rename(tmpPath, filePath);
+}
+
+class AuditRotator {
+  constructor(options = {}) {
+    this.maxLines = options.maxLines || 5000;
+  }
+
+  shouldRotate(filePath) {
+    if (!fs.existsSync(filePath)) return false;
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lineCount = content.split('\n').filter(l => l.trim()).length;
+    return lineCount >= this.maxLines;
+  }
+
+  rotate(filePath, archiveDir) {
+    const dir = archiveDir || path.join(path.dirname(filePath), '..', 'audit-archive');
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const baseName = path.basename(filePath, path.extname(filePath));
+    const archiveName = `${baseName}-${timestamp}.jsonl.gz`;
+    const archivePath = path.join(dir, archiveName);
+
+    // Crash-safe: write archive FIRST, then truncate source
+    const content = fs.readFileSync(filePath);
+    const compressed = zlib.gzipSync(content);
+    fs.writeFileSync(archivePath, compressed);
+
+    const lines = content.toString('utf8').split('\n').filter(l => l.trim());
+    const carryover = lines.slice(-100).join('\n') + '\n';
+    const tmpPath = filePath + '.tmp.' + process.pid;
+    const fd = fs.openSync(tmpPath, 'w');
+    fs.writeSync(fd, carryover);
+    fs.fsyncSync(fd);
+    fs.closeSync(fd);
+    fs.renameSync(tmpPath, filePath);
+
+    return archivePath;
+  }
+}
+
+module.exports = { AuditWriter, AuditRotator, readJSON, writeJSON, readJSONL, readJSONSync, atomicWriteJSON, atomicWriteJSONAsync };

package/bin/utils/index.js

@@ -1,5 +1,63 @@
 'use strict';
+
+class LRUMap {
+  constructor(maxSize, options = {}) {
+    this._max = maxSize;
+    this._onEvict = options.onEvict || null;
+    this._map = new Map();
+  }
+
+  get(key) {
+    if (!this._map.has(key)) return undefined;
+    const value = this._map.get(key);
+    this._map.delete(key);
+    this._map.set(key, value);
+    return value;
+  }
+
+  set(key, value) {
+    if (this._map.has(key)) {
+      this._map.delete(key);
+    } else if (this._map.size >= this._max) {
+      const oldest = this._map.keys().next().value;
+      const oldestValue = this._map.get(oldest);
+      this._map.delete(oldest);
+      if (this._onEvict) this._onEvict(oldest, oldestValue);
+    }
+    this._map.set(key, value);
+  }
+
+  has(key) {
+    return this._map.has(key);
+  }
+
+  delete(key) {
+    return this._map.delete(key);
+  }
+
+  clear() {
+    this._map.clear();
+  }
+
+  get size() {
+    return this._map.size;
+  }
+
+  keys() {
+    return this._map.keys();
+  }
+
+  values() {
+    return this._map.values();
+  }
+
+  entries() {
+    return this._map.entries();
+  }
+}
+
 module.exports = {
+  LRUMap,
   ...require('./paths'),
   ...require('./file-io'),
   ...require('./errors')

package/bin/utils/version-check.js

@@ -0,0 +1,59 @@
+'use strict';
+/**
+ * MindForge version single-source-of-truth + drift detector.
+ * package.json is canonical; everything else must agree.
+ */
+const path = require('path');
+// Use the repo's stricter reader: returns null only on ENOENT and RE-THROWS on
+// parse errors. Re-throwing on a corrupt JSON source is the fail-closed
+// behavior we want — a file we cannot parse means we cannot establish truth.
+const { readJSONSync } = require('./file-io');
+
+/**
+ * @param {string} projectRoot
+ * @returns {{ canonical: string|null, sources: Record<string,string|null>, drift: string[] }}
+ */
+function checkVersionConsistency(projectRoot) {
+  const pkg = readJSONSync(path.join(projectRoot, 'package.json'));
+  const canonical = pkg ? pkg.version : null;
+
+  const configJson = readJSONSync(path.join(projectRoot, '.mindforge', 'config.json'));
+  // Runtime drift coverage is intentionally limited to package.json (canonical)
+  // vs .mindforge/config.json — the live config is the operational drift risk
+  // during `auto`. Wider agreement (sdk/package.json, MINDFORGE.md [VERSION]) is
+  // enforced by the test suite (tests/version-consistency.test.js), not at
+  // runtime — do not assume this checker provides full version coverage.
+  const sources = {
+    'package.json': canonical,
+    '.mindforge/config.json': configJson ? configJson.version : null,
+  };
+
+  const drift = [];
+  // Fail-closed: if we cannot establish the canonical version (package.json
+  // missing or its `version` field absent), treat it as a drift/error condition
+  // rather than silently passing. A genuinely corrupt package.json would have
+  // already thrown out of readJSONSync above.
+  if (!canonical) {
+    drift.push('package.json version could not be determined (canonical source missing or unparseable)');
+    return { canonical, sources, drift };
+  }
+
+  for (const [file, version] of Object.entries(sources)) {
+    if (version && version !== canonical) {
+      drift.push(`${file} declares ${version} but canonical (package.json) is ${canonical}`);
+    }
+  }
+  return { canonical, sources, drift };
+}
+
+/**
+ * Fail-closed assertion for pre-flight. Throws on drift.
+ */
+function assertVersionConsistency(projectRoot) {
+  const { drift } = checkVersionConsistency(projectRoot);
+  if (drift.length > 0) {
+    throw new Error('Version drift detected (fail-closed):\n  - ' + drift.join('\n  - '));
+  }
+}
+
+module.exports = { checkVersionConsistency, assertVersionConsistency };

package/bin/verify-audit.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+'use strict';
+const { verifyAuditChain } = require('./governance/audit-verifier');
+const auditPath = process.argv[2] || '.planning/AUDIT.jsonl';
+const result = verifyAuditChain(auditPath);
+if (result.valid) {
+  process.stdout.write(`✅ audit chain valid: ${result.count} entries\n`);
+  process.exit(0);
+} else {
+  process.stderr.write(`❌ audit chain BROKEN at entry ${result.brokenAt}: ${result.reason}\n`);
+  process.exit(1);
+}

package/bin/wizard/theme.js

@@ -177,8 +177,7 @@ const Theme = {
   },
 
   // --- Aliases for legacy compatibility ---
-  status(label, state) { this.printStatus(label, state); },
-  printSuccess(runtime, scope, stats) { this.printSuccessV2(runtime, scope, stats); }
+  status(label, state) { this.printStatus(label, state); }
 };
 
 module.exports = Theme;

package/docs/getting-started.md

@@ -1,4 +1,4 @@
-# MindForge — Getting Started (v10.0.1)
+# MindForge — Getting Started (v11.0.0)
 
 This guide gets you from zero to a working MindForge project in under five minutes.
 

package/docs/user-guide.md

@@ -1,4 +1,4 @@
-# MindForge User Guide (v10.0.1)
+# MindForge User Guide (v11.0.0)
 
 This guide gets you from install to productive, with the minimum needed to run MindForge in a real project.
 
@@ -136,7 +136,7 @@ Observe your agent waves, token spend, and milestone progress in real-time.
 
 The dashboard provides a premium web interface at `http://localhost:7339`.
 
-> **Authentication (v10.0.1+):** The dashboard now requires a bearer token for access. The token is printed to the console at startup. Pass it in the `Authorization` header or use the login prompt in the browser UI.
+> **Authentication (v11.0.0+):** The dashboard now requires a bearer token for access. The token is printed to the console at startup. Pass it in the `Authorization` header or use the login prompt in the browser UI.
 
 ---
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mindforge-cc",
-  "version": "10.7.0",
-  "description": "MindForge \u2014 Sovereign Agentic Intelligence Framework. Bedrock Fortified: Production-Grade Architecture (v10)",
+  "version": "11.2.0",
+  "description": "MindForge \u2014 Sovereign Agentic Intelligence Framework. Sovereign Stability: Production-Hardened Agentic Intelligence (v11)",
   "bin": {
     "mindforge-cc": "bin/install.js",
     "mindforge": "bin/mindforge-cli.js"