mindforge-cc 11.0.0 → 11.2.1

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 (not module-top-level) to keep this leaf utility free of a
+    // load-time dependency on the autonomous layer and avoid any future require
+    // cycle: bin/autonomous/audit-writer.js is the canonical durable-append site.
+    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;
+  async flush() { /* no-op: appendAuditEntrySync is synchronous + fsync-durable */ }
 
-    const lines = this._buffer.splice(0);
-    const content = lines.join('\n') + '\n';
-
-    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);
@@ -120,45 +110,4 @@ async function atomicWriteJSONAsync(filePath, data) {
   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 };
+module.exports = { AuditWriter, readJSON, writeJSON, readJSONL, readJSONSync, atomicWriteJSON, atomicWriteJSONAsync };

package/bin/utils/version-check.js

@@ -0,0 +1,75 @@
+'use strict';
+/**
+ * MindForge version single-source-of-truth + drift detector.
+ * package.json is canonical; everything else must agree.
+ */
+const fs = require('fs');
+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');
+
+/**
+ * Extracts `[VERSION] = X` from MINDFORGE.md. Returns null when the file is
+ * absent or the marker is missing (treated as skip, not drift).
+ */
+function readMindforgeMdVersion(projectRoot) {
+  const mdPath = path.join(projectRoot, 'MINDFORGE.md');
+  if (!fs.existsSync(mdPath)) return null;
+  const text = fs.readFileSync(mdPath, 'utf8');
+  const match = text.match(/\[VERSION\]\s*=\s*([^\s]+)/);
+  return match ? match[1].trim() : null;
+}
+
+/**
+ * @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'));
+  const sdkPkg = readJSONSync(path.join(projectRoot, 'sdk', 'package.json'));
+  const mindforgeMdVersion = readMindforgeMdVersion(projectRoot);
+  // Runtime coverage now spans every source the test suite knows about, so
+  // drift in any of them halts `auto` — not just the live config. Absent
+  // optional sources (no sdk/, no MINDFORGE.md) read as null and are SKIPPED
+  // (not counted as drift); only a present-but-mismatched source flags drift.
+  const sources = {
+    'package.json': canonical,
+    '.mindforge/config.json': configJson ? configJson.version : null,
+    'sdk/package.json': sdkPkg ? sdkPkg.version : null,
+    'MINDFORGE.md': mindforgeMdVersion,
+  };
+
+  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.1",
   "description": "MindForge \u2014 Sovereign Agentic Intelligence Framework. Sovereign Stability: Production-Hardened Agentic Intelligence (v11)",
   "bin": {
     "mindforge-cc": "bin/install.js",