mindforge-cc 11.0.0 → 11.2.0

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,56 +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);

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindforge-cc",
-  "version": "11.0.0",
+  "version": "11.2.0",
   "description": "MindForge \u2014 Sovereign Agentic Intelligence Framework. Sovereign Stability: Production-Hardened Agentic Intelligence (v11)",
   "bin": {
     "mindforge-cc": "bin/install.js",