mindforge-cc 11.2.0 → 11.2.1

package/.mindforge/config.json

@@ -1,11 +1,11 @@
 {
-  "version": "11.2.0",
+  "version": "11.2.1",
   "environment": "development",
   "governance": {
     "drift_threshold": 0.75,
     "critical_drift_threshold": 0.5,
     "res_threshold": 0.8,
-    "active_did": "did:mindforge:0f5f4777-ffd4-4aef-aa46-e8eb34c0e8c0"
+    "active_did": "did:mindforge:cbca5a94-a796-4919-a1a3-d0488f228611"
   },
   "revops": {
     "market_registry": {
@@ -107,6 +107,7 @@
   },
   "cost_routing": {
     "enabled": true,
+    "shadow_mode": true,
     "simple_threshold": 3,
     "standard_threshold": 6,
     "complex_threshold": 8,

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## [11.2.1] - 2026-05-31 — "Hardening" (security & integrity audit remediation)
+
+Post-v11.2.0 audit remediation. Closes every exploitable security defect and
+false-assurance stub surfaced by the end-to-end audit. No new features, no
+breaking changes — fixes and honest-labeling only.
+
+### Security (fixed)
+
+- **trust-gate-hook**: scans the whole command + every line (a benign first line could previously cloak a destructive later line)
+- **orbital-guardian**: `verify()` re-checks the Ed25519 attestation signature (added `did`/`signed_message` columns + migration); rejects forged APPROVED rows
+- **policy-engine**: `reasoning_proof` alone no longer bypasses the blast-radius limit (`isProofValid` inits false; cryptographic `pq_proof` path unchanged)
+- **shadow-mirror**: git calls use `execFileSync` (argv) + fail-closed `sanitizeRemediationId()` — closes command injection via `remediation_id`
+- **trust-boundaries `isHighImpact`**: added chmod/chown/dd/mv/kill/shutdown/eval/command-substitution/redirect detection + shell-obfuscation normalization; narrowed interpreter-script pattern to stop false-positives on `node <projectfile>`
+- **eis-client**: `verifyRemoteProvenance` delegates to real ZTAI signature verification, fail-closed (was returning true for any non-empty signature)
+
+### Integrity / honest labeling (fixed)
+
+- **ztai-archiver**: `verifyIntegrity()` recomputes the Merkle root from the live log (was a no-op `return true`); fail-closed on tamper/delete/reorder
+- **mesh-self-healer**: emits an honest degraded advisory instead of fabricated 94%/100% consensus
+- **logic-validator**: probes Ollama when reachable, honest heuristic fallback; stopped advertising the dead model path
+- **reason-source-aligner**: consistent return shape (uninitialized no longer silently disables the mission-fidelity gate); real Jaccard similarity
+- **sre-manager**: HMAC artifact relabeled as integrity tag, not "ZK-Proof"
+- **installer-core**: PQAS-enabled message gated on the real `experimental.pqc_demo` flag
+- **finding-synthesizer**: detects real severity-gap contradictions (was hardcoded `[]`)
+- **logic-drift-detector**: relabeled heuristic, not "Neural"
+- **session-manager / shadow-mirror(docker) / regression-writer / skill-registry**: honest disclosure instead of silent empties / fake isolation / tautological tests / mock placeholders
+- **MINDFORGE.md**: `[PQAS_ENFORCED]` reconciled to reflect simulated/inactive default; **ztai-manager** logs relabeled `[ZTAI-HSM-SIM]`
+
+### CI / hygiene
+
+- **release workflow**: asserts the git tag matches `package.json` version (fail-closed) + skips publish if the version is already on npm
+- **version-check**: runtime drift check widened to all 4 sources (was 2); SDK README guarded by test
+- removed dead `AuditRotator` class (CHANGELOG had wrongly claimed it removed); deprecated orphaned `createAppendQueue`
+- refreshed stale `v11.1.0` banners → current; added `cost_routing.shadow_mode` latch
+- version bumped to 11.2.1 across all sources
+
 ## [11.2.0] - 2026-05-31 — "Verification & Trust"
 
 ### Added
@@ -28,7 +64,7 @@
 ### Removed
 
 - Dead `quantum-verify` CLI command entry (no handler existed)
-- Dead `AuditRotator` references (broke hash chain on rotation boundaries)
+- Dead `AuditRotator` class and its export from `bin/utils/file-io.js` (zero callers; rotation broke the hash chain at rotation boundaries — see `bin/autonomous/audit-writer.js`)
 
 ### Changed
 

package/MINDFORGE.md

@@ -1,12 +1,12 @@
-# MINDFORGE.md — Parameter Registry (v11.2.0)
+# MINDFORGE.md — Parameter Registry (v11.2.1)
 
 ## 1. IDENTITY & VERSIONING
 
 [NAME]    = MindForge
-[VERSION] = 11.2.0
+[VERSION] = 11.2.1
 [STABLE]  = true
 [MODE]    = "Platform Sovereign"
-[REQUIRED_CORE_VERSION] = 11.2.0
+[REQUIRED_CORE_VERSION] = 11.2.1
 [SOVEREIGN_IDENTITY] = true
 [SRE_LAYER_ENABLED]  = true
 
@@ -26,7 +26,7 @@
 [ZTAI_KEY_TYPE] = "Dilithium-5"
 [NEXUS_TRACE_RETENTION_DAYS] = 30
 [CADIA_CORE] = true
-[PQAS_ENFORCED] = true
+[PQAS_ENFORCED] = false  # PQAS is SIMULATED/inactive by default (config: pqas_enabled=false, gated behind experimental.pqc_demo). Tier-3 trust uses real Ed25519. See .mindforge/config.json + bin/governance/quantum-crypto.js.
 [PROACTIVE_HOMING] = true
 
 ---
@@ -100,6 +100,6 @@ The following parameters cannot be overridden by plugins, agents, or session-lev
 - [MIN_SOUL_SCORE] — Minimum SOUL score required for architectural changes
 - [BLOCK_ON_SECURITY] — Security gate enforcement cannot be disabled
 - [COST_HARD_LIMIT_USD] — Hard cost limit cannot be raised without human approval
-- [PQAS_ENFORCED] — Post-quantum security cannot be disabled
+- [BLOCK_ON_SECURITY] is non-overridable; PQAS itself is simulated/experimental (inactive by default) and is NOT a non-overridable guarantee — do not rely on it as an enforced control
 - [SOVEREIGN_IDENTITY] — Identity verification is always required
 - [ENABLE_ZTAI] — Zero-trust identity cannot be bypassed

package/bin/autonomous/mesh-self-healer.js

@@ -1,10 +1,18 @@
 /**
  * MindForge v7 — Proactive Semantic Homing (Pillar XII)
  * Mesh Self-Healer: Peer agents "home in" on drifting nodes to provide collaborative reasoning.
+ *
+ * UC-22 (audit finding #16) — HONEST LABELLING:
+ * There is no live, runtime peer-reasoning mesh in this build. Previously this
+ * module FABRICATED a collective consensus (hardcoded peers, canned
+ * confidence:94, "100% agreement" log). That emitted false assurance on the
+ * live auto-runner self-heal path. It now consults the ONLY real peer source
+ * available — the ztai-manager session-agent registry — and, when that yields
+ * no real peers (the common case at runtime), degrades GRACEFULLY to a clearly
+ * labelled single-source advisory with NO fabricated confidence or consensus.
  */
 'use strict';
 
-const fs = require('node:fs');
 const path = require('node:path');
 
 class MeshSelfHealer {
@@ -14,52 +22,117 @@ class MeshSelfHealer {
 
   /**
    * Peer agents "home in" on a node with high logic drift.
+   *
+   * @param {string} driftingAgentDid - DID of the drifting node.
+   * @param {number} driftScore - Logic-drift score (only acts on >= 80).
+   * @param {object} [options] - { sessionId } to scope the real peer lookup.
+   * @returns {Promise<object|null>} Honest advisory object, or null below threshold.
    */
-  async homeIn(driftingAgentDid, driftScore) {
+  async homeIn(driftingAgentDid, driftScore, options = {}) {
     if (driftScore < 80) return null; // Only home in on major drift
-    
-    console.log(`[HOMING-HEAL] Global Mesh Alert: Agent ${driftingAgentDid} experiencing critical logic drift (${driftScore}). Peer agents redirecting...`);
-    
-    // Find nearby idle agents or specialists
-    const peers = this.findAvailablePeers(driftingAgentDid);
-    const healingNodes = [];
 
+    console.log(`[HOMING-HEAL] Global Mesh Alert: Agent ${driftingAgentDid} experiencing critical logic drift (${driftScore}). Seeking peer reasoning support...`);
+
+    // Consult the only REAL peer source: the ztai-manager session registry.
+    // Returns an empty array when no live peers are registered.
+    const peers = this.findAvailablePeers(driftingAgentDid, options.sessionId);
+
+    if (peers.length === 0) {
+      return this.degradedAdvisory(driftingAgentDid);
+    }
+
+    const healingNodes = [];
     for (const peer of peers) {
-      console.log(`[HOMING-HEAL] Agent ${peer.did} homing in on ${driftingAgentDid} to provide collective reasoning support.`);
+      console.log(`[HOMING-HEAL] Peer ${peer.did} homing in on ${driftingAgentDid} to provide reasoning support.`);
       const supportTrace = await this.provideCollectiveReasoning(peer, driftingAgentDid);
       healingNodes.push(supportTrace);
     }
 
-    return this.reconcileReasoning(healingNodes);
+    return this.reconcileReasoning(healingNodes, driftingAgentDid);
+  }
+
+  /**
+   * Discovers REAL peer agents from the live registry. There are no invented
+   * peers — if nothing is registered for the session, this returns []
+   * and the caller degrades honestly.
+   *
+   * @param {string} driftingAgentDid - The node being healed (excluded from peers).
+   * @param {string|null} sessionId - Session scope for the registry lookup.
+   * @returns {Array<{did:string, persona?:string}>} Real peers (possibly empty).
+   */
+  findAvailablePeers(driftingAgentDid, sessionId = null) {
+    let agents = [];
+    try {
+      // Lazy require to avoid a hard coupling / load cost on the cold path.
+      const ztaiManager = require('../governance/ztai-manager');
+      if (typeof ztaiManager.getSessionAgents === 'function') {
+        agents = ztaiManager.getSessionAgents(sessionId) || [];
+      }
+    } catch {
+      // No registry available — treat as no live peers (honest degraded mode).
+      agents = [];
+    }
+
+    // Exclude the drifting node itself; only real, distinct peers may help.
+    return agents.filter(a => a && a.did && a.did !== driftingAgentDid);
   }
 
-  findAvailablePeers(driftingAgentDid) {
-    // Simulated peer discovery
-    return [
-      { did: 'did:mindforge:peer-1-specialist', name: 'Refactor Specialist' },
-      { did: 'did:mindforge:peer-2-architect', name: 'Security Architect' }
-    ];
+  /**
+   * Honest single-source advisory used when no live peer mesh is available.
+   * Carries NO fabricated confidence and makes NO consensus claim.
+   *
+   * @param {string} driftingAgentDid
+   * @returns {object}
+   */
+  degradedAdvisory(driftingAgentDid) {
+    console.log('[HOMING-HEAL] No live peer mesh available — emitting single-source advisory (degraded).');
+
+    return {
+      type: 'advisory',
+      mesh_available: false,
+      degraded: true,
+      confidence: null,
+      consensus: null,
+      target: driftingAgentDid,
+      recommendation: 'Heuristic single-source steering: pause the drifting node, re-anchor to the last verified plan/spec, and require human or higher-tier review before resuming. No multi-agent consensus was available to corroborate this.',
+      source: 'Mesh-Self-Healing (degraded: no live peers)'
+    };
   }
 
   async provideCollectiveReasoning(peer, target) {
-    // Peer agent provides a second opinion/reasoning node
+    // A real peer contributes a reasoning node. Confidence is left null here:
+    // this build has no model-backed scoring, so we do not invent a number.
     return {
       provider: peer.did,
-      target: target,
-      reasoning: 'Recommended steering for drift recovery based on Mesh-State: Re-syncing with Sovereign-Reason-Enclave.',
-      confidence: 94
+      target,
+      reasoning: 'Peer steering note: re-sync drifting node with the last verified plan state.',
+      confidence: null
     };
   }
 
-  reconcileReasoning(nodes) {
-    // Merge peer reasoning nodes into a single corrective steering vector
-    const consensus = nodes[0].reasoning; // Mock consensus
-    console.log('[HOMING-HEAL] Collective reasoning consensus acheived: 100% agreement on recovery vector.');
-    
+  /**
+   * Reconciles multiple REAL peer reasoning nodes. With live peers present we
+   * report how many corroborated, but we still never invent a confidence score
+   * or a "100% agreement" claim.
+   *
+   * @param {Array<object>} nodes - Real peer reasoning contributions.
+   * @param {string} driftingAgentDid
+   * @returns {object}
+   */
+  reconcileReasoning(nodes, driftingAgentDid) {
+    const peerCount = nodes.length;
+    console.log(`[HOMING-HEAL] Collective reasoning gathered from ${peerCount} live peer(s); no confidence fabricated.`);
+
     return {
-      type: 'collective_repair',
-      consensus,
-      source: 'Mesh-Self-Healing'
+      type: 'advisory',
+      mesh_available: true,
+      degraded: false,
+      confidence: null, // No model-backed scoring in this build — stay honest.
+      consensus: nodes[0].reasoning,
+      peer_count: peerCount,
+      target: driftingAgentDid,
+      recommendation: nodes[0].reasoning,
+      source: `Mesh-Self-Healing (${peerCount} live peer(s))`
     };
   }
 }

package/bin/browser/regression-writer.js

@@ -10,12 +10,54 @@ function write(bug, phaseNum) {
   const dir = path.join(process.cwd(), 'tests', 'regression');
   fs.mkdirSync(dir, { recursive: true });
   const name = `phase${phaseNum}-${bug.surface.replace(/\//g, '-').slice(1) || 'home'}.test.ts`;
+
+  // Embed the bug's surface and failure signal as safely-escaped JS string
+  // literals. JSON.stringify escapes quotes, backticks and ${...} so a
+  // freeform bug.error cannot break out of the generated source.
+  const surfaceLit = JSON.stringify(bug.surface);
+  const errorLit   = JSON.stringify(bug.error);
+
+  // The generated test reproduces the original failure conditions and asserts
+  // the page no longer exhibits THIS bug's signal — it is NOT a body-visibility
+  // tautology that passes for any page.
   const content = `
 import { test, expect } from '@playwright/test';
 
-test('Regression: ${bug.surface} [${bug.error}]', async ({ page }) => {
-  await page.goto('${bug.surface}');
-  // TODO: Add more specific assertions based on the bug
+// Regression guard for the bug originally observed on ${bug.surface}:
+//   ${String(bug.error).replace(/[\r\n]+/g, ' ')}
+// This test fails again if that failure signal re-appears (console error,
+// page text, or a >=400 HTTP status on the affected surface).
+const SURFACE = ${surfaceLit};
+const BUG_SIGNAL = ${errorLit};
+
+test('Regression: ' + SURFACE + ' [' + BUG_SIGNAL + ']', async ({ page }) => {
+  const consoleErrors: string[] = [];
+  page.on('console', (msg) => {
+    if (msg.type() === 'error') consoleErrors.push(msg.text());
+  });
+  page.on('pageerror', (err) => consoleErrors.push(String(err)));
+
+  const response = await page.goto(SURFACE);
+
+  // 1. The affected surface must load without the original HTTP failure.
+  if (response) {
+    expect(response.status(), 'surface re-returned a failing HTTP status').toBeLessThan(400);
+  }
+
+  // 2. The specific failure signal must not re-appear in the console.
+  expect(
+    consoleErrors.some((line) => line.includes(BUG_SIGNAL)),
+    'console re-emitted the original error: ' + BUG_SIGNAL
+  ).toBeFalsy();
+
+  // 3. ...nor be surfaced in the rendered page text.
+  const bodyText = await page.textContent('body');
+  expect(
+    (bodyText || '').includes(BUG_SIGNAL),
+    'page re-rendered the original error: ' + BUG_SIGNAL
+  ).toBeFalsy();
+
+  // 4. Smoke check: the page actually rendered something.
   expect(await page.isVisible('body')).toBeTruthy();
 });
 `;

package/bin/browser/session-manager.js

@@ -7,7 +7,6 @@
 
 const fs   = require('fs');
 const path = require('path');
-const os   = require('os');
 
 const SESSIONS_DIR = path.join(process.cwd(), '.mindforge', 'browser', 'sessions');
 const ensureDir = () => fs.mkdirSync(SESSIONS_DIR, { recursive: true });
@@ -71,23 +70,28 @@ async function loadSession(name, context) {
   return { cookiesLoaded };
 }
 
+/**
+ * Import cookies/sessions directly from a native browser profile.
+ *
+ * NOT IMPLEMENTED: native browser cookie DB import was removed together with
+ * the `better-sqlite3` dependency (the project now uses sql.js / WASM). Browser
+ * cookie stores are SQLite databases, and decoding them required that native
+ * backend. Rather than silently returning an empty array — which would lie about
+ * capability and let callers mistake "no cookies imported" for success — this
+ * method throws so the missing capability is explicit.
+ *
+ * To populate a session, capture cookies live via a browser context and use
+ * `saveSession` / `loadSession` instead.
+ *
+ * @param {string} source - Browser identifier (chrome, arc, brave, edge).
+ * @throws {Error} Always — native browser cookie import is not implemented.
+ */
 function importFromBrowser(source) {
-  const home = os.homedir();
-  const paths = {
-    chrome: `${home}/Library/Application Support/Google/Chrome/Default/Cookies`,
-    arc: `${home}/Library/Application Support/Arc/User Data/Default/Cookies`,
-    brave: `${home}/Library/Application Support/BraveSoftware/Brave-Browser/Default/Cookies`,
-    edge: `${home}/Library/Application Support/Microsoft Edge/Default/Cookies`,
-  };
-
-  const p = paths[source.toLowerCase()];
-  if (!p || !fs.existsSync(p)) {
-    throw new Error(`Cookie file for ${source} not found at ${p}`);
-  }
-
-  // Real SQLite parsing would happen here via better-sqlite3 if installed.
-  // This is a placeholder for the logic specified in the roadmap.
-  return [];
+  throw new Error(
+    `importFromBrowser not implemented for "${source}": the native browser ` +
+    'cookie-DB backend (better-sqlite3) was removed project-wide. ' +
+    'Capture cookies live via a browser context and use saveSession/loadSession instead.'
+  );
 }
 
 module.exports = { saveSession, loadSession, importFromBrowser };

package/bin/engine/logic-drift-detector.js

@@ -1,9 +1,15 @@
 /**
- * MindForge v6.1.0-alpha — Neural Drift Remediation (NDR)
- * Component: Logic Drift Detector (Pillar X)
- * 
- * Analyzes reasoning traces for "Semantic Decay" (repeated failure patterns, 
- * hallucination-like markers, or mission drift).
+ * MindForge v6.1.0-alpha — Logic Drift Detector (Pillar X)
+ *
+ * HEURISTIC drift detector. Despite the "Pillar X" product naming, this
+ * component does NOT use a neural network, embeddings, or any learned model.
+ * It scores reasoning traces using pure keyword/ratio heuristics:
+ *   - unique-word-to-total ratio (proxy for "rambling")
+ *   - max word-repetition count (proxy for circular reasoning)
+ *   - presence of a small hardcoded list of contradiction phrases
+ *
+ * Flags "Semantic Decay" (repeated failure patterns, contradiction markers,
+ * or mission drift) heuristically. No model inference is performed.
  */
 'use strict';
 
@@ -48,7 +54,9 @@ class LogicDriftDetector {
   }
 
   /**
-   * Internal Heuristic: Detects low semantic density (rambling).
+   * Internal Heuristic: approximates "rambling" via a unique-keyword-to-word
+   * ratio. NOTE: this is NOT a semantic/embedding measure — "density" here is
+   * a plain lexical ratio, not model-derived semantic similarity.
    */
   _calculateSemanticDensity(thought) {
     const words = thought.split(/\s+/).length;

package/bin/engine/logic-validator.js

@@ -1,67 +1,197 @@
 /**
  * MindForge v7 — Neural Drift Remediation (NDR)
  * Component: Logic Validator
- * 
+ *
  * Performs high-level semantic validation on agent reasoning traces.
- * Supports Local Model (Ollama) integration and Self-Reflective Heuristics.
+ *
+ * Strategy: real-when-available, else honest heuristic.
+ *   - By DEFAULT this validator uses a local Self-Reflective Heuristic
+ *     (`_reflectiveHeuristic`). This is the standard path and runs everywhere,
+ *     with no external dependency.
+ *   - OPTIONALLY, if a local Ollama model is actually reachable at the
+ *     configured endpoint, validation is upgraded to a real model call
+ *     (`_modelValidation`). Reachability is determined by a real, fail-fast
+ *     network probe — never a hardcoded flag. When Ollama is absent (the
+ *     normal case) the probe fails fast and we fall back to the heuristic.
+ *
+ * The return shape is stable: { is_valid, confidence, critique, method }.
+ * Consumers (nexus-tracer) read `is_valid` and `critique`.
  */
 'use strict';
 
 const configManager = require('../governance/config-manager');
 
+// Fail-fast budget for the reachability probe and the model call. Ollama is
+// usually absent, so this must time out quickly to avoid hanging CI/production.
+const PROBE_TIMEOUT_MS = 400;
+const MODEL_TIMEOUT_MS = 4000;
+
 class LogicValidator {
   constructor() {
     this.endpoint = configManager.get('governance.local_model_endpoint', 'localhost:11434');
-    this.isModelAvailable = false; // Simulated check result
+    this.model = configManager.get('governance.local_model_name', 'llama3');
+    // Reflects reality: set by probeModel(), not hardcoded. Unknown until probed.
+    this.isModelAvailable = false;
+    this._probed = false;
+  }
+
+  /**
+   * Normalises the configured endpoint into a base URL (adds scheme if absent).
+   * @returns {string}
+   */
+  _baseUrl() {
+    const ep = String(this.endpoint || 'localhost:11434').trim();
+    return /^https?:\/\//i.test(ep) ? ep.replace(/\/+$/, '') : `http://${ep.replace(/\/+$/, '')}`;
+  }
+
+  /**
+   * Resets cached probe state (used by tests to re-probe after changing endpoint).
+   */
+  resetProbe() {
+    this._probed = false;
+    this.isModelAvailable = false;
+  }
+
+  /**
+   * Real, fail-fast reachability check for a local Ollama instance.
+   * Performs a short GET to the Ollama tags endpoint. On ANY error or timeout
+   * (the normal case when Ollama is absent) it resolves `false` — never throws,
+   * never hangs. Sets `this.isModelAvailable` from the actual result.
+   * @returns {Promise<boolean>}
+   */
+  async probeModel() {
+    let reachable = false;
+    try {
+      const res = await fetch(`${this._baseUrl()}/api/tags`, {
+        method: 'GET',
+        signal: AbortSignal.timeout(PROBE_TIMEOUT_MS)
+      });
+      reachable = res.ok;
+    } catch {
+      // ECONNREFUSED / timeout / DNS / abort — Ollama not reachable. Stay quiet.
+      reachable = false;
+    }
+    this.isModelAvailable = reachable;
+    this._probed = true;
+    return reachable;
   }
 
   /**
    * Validates a reasoning trace using the best available method.
+   * Probes for a local model on first call (lazy); falls back to the heuristic
+   * when unreachable.
    * @param {string} thought - The agent's thought string
    * @param {Object} context - Optional metadata (span attributes, etc.)
    */
   async validate(thought, context = {}) {
-    console.log(`[LogicValidator] Validating trace segment (Length: ${thought.length})`);
+    const spanTag = context && context.span_id ? ` span=${context.span_id}` : '';
+    console.log(`[LogicValidator] Validating trace segment (Length: ${thought.length})${spanTag}`);
+
+    if (!this._probed) {
+      await this.probeModel();
+    }
 
-    // In a real v7 deployment, we would perform an asynchronous fetch to Ollama/Llama-CPP
-    // For this simulation, we simulate a "Reflective Heuristic" analysis.
-    
     if (this.isModelAvailable) {
-      return this._modelValidation(thought, context);
-    } else {
-      return this._reflectiveHeuristic(thought, context);
+      try {
+        return await this._modelValidation(thought);
+      } catch {
+        // Model became unreachable mid-flight — degrade honestly to heuristic.
+        this.isModelAvailable = false;
+        return this._reflectiveHeuristic(thought);
+      }
     }
+    return this._reflectiveHeuristic(thought);
   }
 
   /**
-   * Simulated Local Model Validation logic.
+   * Real Local Model Validation via Ollama's /api/generate.
+   * Asks the model whether the thought is logical and grounded, then derives a
+   * real is_valid/confidence from the response — no fabricated fixed values.
    */
-  async _modelValidation(thought, context) {
-    // Mocking an LLM callback: "Is this thought logical and grounded?"
-    const result = {
-      is_valid: true,
-      confidence: 0.98,
-      critique: 'Logic is consistent with project goals.',
-      method: 'Ollama/Llama-3-8B'
+  async _modelValidation(thought) {
+    const prompt =
+      'You are a reasoning-trace auditor. Decide whether the following agent ' +
+      'thought is logical and grounded (consistent, on-task, no self-contradiction).\n' +
+      'Reply with ONLY a JSON object: {"valid": <true|false>, "confidence": <0..1>, ' +
+      '"critique": "<short reason>"}.\n\n' +
+      `Thought: """${thought}"""`;
+
+    const res = await fetch(`${this._baseUrl()}/api/generate`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ model: this.model, prompt, stream: false }),
+      signal: AbortSignal.timeout(MODEL_TIMEOUT_MS)
+    });
+
+    if (!res.ok) {
+      throw new Error(`Ollama responded ${res.status}`);
+    }
+
+    const payload = await res.json();
+    const parsed = this._parseModelResponse(payload && payload.response);
+
+    return {
+      is_valid: parsed.valid,
+      confidence: parsed.confidence,
+      critique: parsed.critique,
+      method: `ollama:${this.model}`
+    };
+  }
+
+  /**
+   * Robustly parses the model's textual response into a verdict. Falls back to
+   * conservative defaults derived from the raw text when JSON is unavailable —
+   * never invents a fixed high-confidence pass.
+   * @param {string} raw
+   */
+  _parseModelResponse(raw) {
+    const text = String(raw || '');
+    const match = text.match(/\{[\s\S]*\}/);
+    if (match) {
+      try {
+        const obj = JSON.parse(match[0]);
+        const valid = obj.valid === true || obj.valid === 'true';
+        let confidence = Number(obj.confidence);
+        if (!Number.isFinite(confidence)) confidence = valid ? 0.6 : 0.4;
+        confidence = Math.min(1, Math.max(0, confidence));
+        const critique = typeof obj.critique === 'string' && obj.critique.trim()
+          ? obj.critique.trim()
+          : (valid ? 'Model judged the thought logical and grounded.'
+                   : 'Model flagged the thought as illogical or ungrounded.');
+        return { valid, confidence, critique };
+      } catch {
+        // fall through to text heuristic below
+      }
+    }
+
+    // No parseable JSON: derive a conservative verdict from the raw text.
+    const lowered = text.toLowerCase();
+    const valid = !/(invalid|illogical|not\s+grounded|inconsistent|"valid"\s*:\s*false)/.test(lowered)
+      && /(valid|logical|grounded|consistent)/.test(lowered);
+    return {
+      valid,
+      confidence: valid ? 0.55 : 0.45,
+      critique: 'Model response was unstructured; verdict derived from text.'
     };
-    return result;
   }
 
   /**
-   * Advanced "Reflective Heuristic" which is more intensive than the DriftDetector.
+   * Local Self-Reflective Heuristic — the default validation path. More
+   * intensive than the DriftDetector; uses self-doubt and goal-misalignment
+   * markers. Honestly labelled as a heuristic (no model is involved here).
    */
-  async _reflectiveHeuristic(thought, context) {
-    const t = thought.toLowerCase();
-    
+  async _reflectiveHeuristic(thought) {
+    const t = String(thought || '').toLowerCase();
+
     // Check for "Self-Doubt" markers that might indicate drift
     const doubtMarkers = ['i am not sure', 'maybe i should wait', 'actually, i forgot', 'i will instead try to just'];
     const doubtCount = doubtMarkers.filter(m => t.includes(m)).length;
 
-    // Check for "Goal Misalignment" (Simulated)
+    // Check for "Goal Misalignment"
     const goalMismatch = t.includes('ignoring current goal') || t.includes('outside scope');
 
     const score = 1.0 - (doubtCount * 0.2) - (goalMismatch ? 0.5 : 0);
-    
+
     return {
       is_valid: score > 0.6,
       confidence: parseFloat(score.toFixed(2)),