mindforge-cc 11.5.0 → 11.5.1

package/.mindforge/config.json

@@ -1,11 +1,11 @@
 {
-  "version": "11.5.0",
+  "version": "11.5.1",
   "environment": "development",
   "governance": {
     "drift_threshold": 0.75,
     "critical_drift_threshold": 0.5,
     "res_threshold": 0.8,
-    "active_did": "did:mindforge:f5ee24cf-f359-475e-bd76-c83e3d6fce02"
+    "active_did": "did:mindforge:7dffeae7-eb70-45c9-9001-701fba7809d2"
   },
   "revops": {
     "market_registry": {

package/.mindforge/memory/sync-manifest.json

@@ -1,6 +1,6 @@
 {
   "pattern-library.jsonl": {
-    "lastSync": "2026-06-11T08:14:04.496Z",
+    "lastSync": "2026-06-11T11:41:34.054Z",
     "localCount": 1
   }
 }

package/CHANGELOG.md

@@ -1,5 +1,50 @@
 # Changelog
 
+## [11.5.1] - 2026-06-11 — Robustness + governance-gate patch (Wave 8)
+
+A fast-follow patch from a fresh adversarial audit of the shipped v11.5.0 tree.
+Hardens crash-prone JSON parsing in the autonomous/memory pipelines, closes a
+CI governance-gate gap, and tightens two security surfaces. No new features.
+
+### Fixed
+
+- **Crash-proof AUDIT.jsonl parsing** (`bin/memory/pillar-health-tracker.js`) —
+  `summarizePhase()` parsed every audit line with an unguarded `JSON.parse`, so a
+  single malformed/torn line crashed the knowledge-capture pipeline. Now parses
+  per-line in try/catch and skips bad lines.
+- **Crash-proof compaction capture** (`bin/memory/knowledge-capture.js`) — a
+  malformed `handoff.json` no longer throws out of `captureFromCompaction()`; it
+  logs and returns `[]`, mirroring the missing-file path.
+- **Resilient federated-sync stats** (`bin/memory/federated-sync.js`) — the two
+  unguarded `JSON.parse` calls on `sync-stats.json` (`handleSyncFailure`,
+  `resetFailures`) now fall back to `{failures:0}` on corruption, matching the
+  sibling `getLastSyncTimestamp` pattern.
+
+### Security
+
+- **CI Tier-3 governance gate now validates content** (`.github/workflows/control-plane.yml`)
+  — the gate counted approval files but never checked them; it now requires at
+  least one approval with `identity_verification.verified === true` and a
+  signature, and rejects any unverified/empty file. Completes the Wave-6
+  fail-closed `approve.js` work (a hand-committed empty approval no longer passes).
+- **Dashboard approval attribution** (`bin/dashboard/api-router.js`) —
+  `POST /api/approve/:id` no longer records the client-supplied `approver`
+  (forgeable audit identity); it attributes the action to a fixed authenticated
+  actor. The dashboard remains localhost-bound + token-gated.
+- **Destructive-command detector blocks Unix `truncate`** (`bin/security/trust-boundaries.js`)
+  — the SQL-only `truncate table` pattern missed `truncate -s 0 <path>` (in-place
+  file zeroing). Added a size-flag pattern so it is gated; benign uses stay allowed.
+- **CI Tier-3 gate accepts an explicitly-acknowledged unverified approval**
+  (`.github/workflows/control-plane.yml`, `bin/governance/approve.js`) — since this
+  repo has no GPG signing infra, the gate accepts an approval that is either
+  GPG-verified OR an opted-in `unverified_ack` record (`approve.js` under
+  `MINDFORGE_ALLOW_UNVERIFIED_APPROVAL=1`), while still rejecting bare/stale
+  `verified:false` files. Replaced the stale v11.4.0 approval with a fresh one.
+- **`uuid` dependency removed from `ads-engine`** (`bin/review/ads-engine.js`) — it
+  required the uninstalled `uuid` package, making `ads-engine` and (transitively)
+  `federated-sync` un-loadable in a clean install. Swapped to the built-in
+  `crypto.randomUUID()` (zero-native-deps); both modules now load.
+
 ## [11.5.0] - 2026-06-11 — Governance hardening + autonomous-engine repair (Waves 4–7)
 
 This release bundles four waves of work: orchestration primitives, an **inert** manifest

package/MINDFORGE.md

@@ -1,12 +1,12 @@
-# MINDFORGE.md — Parameter Registry (v11.5.0)
+# MINDFORGE.md — Parameter Registry (v11.5.1)
 
 ## 1. IDENTITY & VERSIONING
 
 [NAME]    = MindForge
-[VERSION] = 11.5.0
+[VERSION] = 11.5.1
 [STABLE]  = true
 [MODE]    = "Platform Sovereign"
-[REQUIRED_CORE_VERSION] = 11.5.0
+[REQUIRED_CORE_VERSION] = 11.5.1
 [SOVEREIGN_IDENTITY] = true
 [SRE_LAYER_ENABLED]  = true
 

package/README.md

@@ -501,4 +501,3 @@ MindForge never stores credentials in files. Review:
 
 ## ⚖️ License
 MIT © 2026 MindForge Team
-eam

package/RELEASENOTES.md

@@ -1,5 +1,50 @@
 # Release Notes
 
+## v11.5.1 — Robustness + governance-gate patch
+
+**Release Date**: 2026-06-11
+**Type**: Patch (no API changes; one CI-gate behavior change)
+**Upgrade Path**: `npx mindforge-cc@latest`
+
+A fast-follow patch driven by a fresh adversarial audit of the shipped v11.5.0
+tree. It hardens crash-prone JSON parsing in the autonomous/memory pipelines,
+closes a governance-gate gap left by the v11.5.0 approval work, and tightens two
+security surfaces. No features, no API changes.
+
+### Robustness — no more crashes on a torn JSONL line
+
+Three pipelines parsed JSON without guards, so one malformed/partially-written
+line could crash them:
+
+- `summarizePhase()` (pillar-health) parsed every `AUDIT.jsonl` line unguarded —
+  it now skips bad lines and keeps the valid ones.
+- `captureFromCompaction()` (knowledge-capture) now returns `[]` on a malformed
+  `handoff.json` instead of throwing.
+- `federated-sync` now tolerates a corrupted `sync-stats.json` in both
+  `handleSyncFailure` and `resetFailures` (falls back to `{failures:0}`).
+
+### Security & governance
+
+- **The CI Tier-3 gate now actually validates approvals.** Previously it only
+  counted approval files; a hand-committed empty file would pass. It now requires
+  each approval to carry a signature and be EITHER GPG-verified
+  (`verified: true`) OR an explicitly opted-in unverified approval
+  (`unverified_ack`, minted by `approve.js` under
+  `MINDFORGE_ALLOW_UNVERIFIED_APPROVAL=1` for repos without GPG infra). Bare or
+  stale `verified:false` files are still rejected — completing the v11.5.0
+  fail-closed `approve.js` work.
+- **Dashboard approvals can't forge an identity.** `POST /api/approve/:id` no
+  longer records a client-supplied `approver` into the audit trail; it attributes
+  the action to a fixed authenticated actor. (The dashboard is already
+  localhost-bound and Bearer-token gated, so this is attribution hardening.)
+- **The destructive-command guard now blocks Unix `truncate -s`.** In-place file
+  zeroing (`truncate -s 0 <path>`) was missed by the SQL-only pattern; it is now
+  gated, with benign uses unaffected.
+- **A shipped module that couldn't load is fixed.** `bin/review/ads-engine.js`
+  required the uninstalled `uuid` package — so it (and the `federated-sync` that
+  imports it) threw on load in a clean install. Swapped to the built-in
+  `crypto.randomUUID()`; no new dependency.
+
 ## v11.5.0 — Governance hardening + autonomous-engine repair
 
 **Release Date**: 2026-06-11

package/bin/dashboard/api-router.js

@@ -75,12 +75,21 @@ function register(app) {
   app.post('/api/approve/:id', (req, res) => {
     try {
       const { id }                  = req.params;
-      const { decision, comment, approver } = req.body || {};
+      const { decision, comment }   = req.body || {};
 
       if (!decision) {
         return res.status(400).json({ error: 'Missing "decision" field (approve|reject)' });
       }
 
+      // SECURITY (v11.5.1): do NOT trust a client-supplied `approver` for the
+      // recorded identity — it is forgeable and would let any caller write a
+      // false approval audit trail (e.g. resolved_by: 'admin'). requireAuth
+      // (server.js) proves the caller holds the owner-only dashboard token but
+      // exposes no named principal, so we attribute the action to a FIXED
+      // trusted actor. (A future RBAC pass can map a Bearer token -> DID and
+      // record the real principal; until then, never echo req.body.approver.)
+      const approver = 'dashboard-authenticated';
+
       const result = Approval.processDecision(id, decision, comment, approver);
 
       if (!result.success) {

package/bin/governance/approve.js

@@ -59,7 +59,11 @@ function verifyApproverIdentity(approver) {
     }
     console.warn('[GOVERNANCE] No GPG key — minting an UNVERIFIED approval (MINDFORGE_ALLOW_UNVERIFIED_APPROVAL=1). ' +
       'git identity is spoofable; this approval is NOT cryptographically attributed.');
-    return { verified: false, method: 'git_identity_unverified', identity: approver };
+    // unverified_ack=true is the EXPLICIT, audited override the CI Tier-3 gate
+    // looks for. A bare verified:false record WITHOUT this marker (e.g. a stale
+    // pre-fail-closed file or a hand-forged empty one) is still rejected by the
+    // gate — only a deliberately opted-in unverified approval is accepted.
+    return { verified: false, method: 'git_identity_unverified', identity: approver, unverified_ack: true };
   }
 
   return { verified: true, method: 'gpg_key', identity: approver, keyId: gpgKey };

package/bin/memory/federated-sync.js

@@ -58,7 +58,11 @@ class FederatedSync {
     const statsPath = path.join(this.localStore.getPaths().MEMORY_DIR, 'sync-stats.json');
     let stats = { failures: 0 };
     if (fs.existsSync(statsPath)) {
-      stats = JSON.parse(fs.readFileSync(statsPath, 'utf8'));
+      try {
+        stats = JSON.parse(fs.readFileSync(statsPath, 'utf8'));
+      } catch {
+        stats = { failures: 0 };
+      }
     }
     stats.failures = (stats.failures || 0) + 1;
     stats.last_error = err.message;
@@ -122,7 +126,12 @@ class FederatedSync {
   resetFailures() {
     const statsPath = path.join(this.localStore.getPaths().MEMORY_DIR, 'sync-stats.json');
     if (fs.existsSync(statsPath)) {
-      const stats = JSON.parse(fs.readFileSync(statsPath, 'utf8'));
+      let stats = { failures: 0 };
+      try {
+        stats = JSON.parse(fs.readFileSync(statsPath, 'utf8'));
+      } catch {
+        stats = { failures: 0 };
+      }
       stats.failures = 0;
       fs.writeFileSync(statsPath, JSON.stringify(stats, null, 2));
     }

package/bin/memory/knowledge-capture.js

@@ -238,7 +238,16 @@ function captureFromPhaseCompletion(phaseNum) {
 function captureFromCompaction(handoffPath) {
   if (!fs.existsSync(handoffPath)) return [];
 
-  const handoff = JSON.parse(fs.readFileSync(handoffPath, 'utf8'));
+  let handoff;
+  try {
+    handoff = JSON.parse(fs.readFileSync(handoffPath, 'utf8'));
+  } catch (err) {
+    // Malformed handoff.json must not crash the capture pipeline — mirror the
+    // missing-file path and return [] after logging the parse failure.
+    console.error(`[knowledge-capture] Failed to parse handoff file ${handoffPath}: ${err.message}`);
+    return [];
+  }
+
   const items   = handoff.implicit_knowledge || [];
   const project = getProjectName();
   const captured = [];

package/bin/memory/pillar-health-tracker.js

@@ -18,7 +18,15 @@ class PillarHealthTracker {
     if (!fs.existsSync(auditPath)) return null;
 
     const lines = fs.readFileSync(auditPath, 'utf8').trim().split('\n');
-    const events = lines.map(l => JSON.parse(l));
+    const events = lines
+      .map(l => {
+        try {
+          return JSON.parse(l);
+        } catch {
+          return null; // Skip malformed lines rather than crashing the pipeline.
+        }
+      })
+      .filter(Boolean);
 
     // 1. RSA (Mission Fidelity) Analysis
     const rsaEvents = events.filter(e => e.type === 'mission_fidelity' || e.event === 'scs_homing_injected');

package/bin/review/ads-engine.js

@@ -8,7 +8,7 @@ const fs = require('fs');
 const path = require('path');
 const ModelClient = require('../models/model-client');
 const { calculateSoulScore, parseMetrics, synthesizeADSPlan } = require('./ads-synthesizer');
-const { v4: uuidv4 } = require('uuid');
+const crypto = require('crypto');
 
 async function runADSSynthesis(params) {
   const {
@@ -89,7 +89,7 @@ Finalize the PLAN.md. Include the [ADS_VERDICT]: [MERGED|BLUE|RED] (Score: X.XXX
   process.stdout.write('done.\n');
 
   // Finalize outputs
-  const adsUuid = uuidv4();
+  const adsUuid = crypto.randomUUID();
   const adrDir = path.join(process.cwd(), '.planning', 'decisions');
   if (!fs.existsSync(adrDir)) fs.mkdirSync(adrDir, { recursive: true });
 

package/bin/security/trust-boundaries.js

@@ -124,6 +124,11 @@ function isHighImpact(command) {
     /git\s+reset\s+--hard/i,
     /delete\s+from/i,
     /truncate\s+table/i,
+    // Unix `truncate -s <size> <path>` zeroes/shrinks a file in place — a
+    // destructive data-loss op the SQL-only `truncate table` pattern above
+    // misses. Match the size flag (-s, -s0, --size) so `truncate -s 0 <path>`
+    // is gated; benign words ("truncated output") and the SQL form are not.
+    /\btruncate\s+(-{1,2}s\w*|--size)\b/i,
     /\bmkfs(\.\w+)?\s+\/dev\//i,
     // #11: any dd write target, not just /dev/ (dd if=... of=important.db).
     // Original /dev/-only check is a subset of this, so it stays covered.

package/package.json

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