mindforge-cc 11.0.0 → 11.2.1

package/bin/engine/verification-runner.js

@@ -0,0 +1,131 @@
+'use strict';
+
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const MAX_OUTPUT_LENGTH = 2000;
+
+/**
+ * Stage definitions — each maps a stage name to its command and optional skip condition.
+ * The tests stage guards against recursion: if NODE_ENV=test (set by run-all.js) or
+ * MINDFORGE_VERIFICATION_ACTIVE=1 (set by this runner), we skip to prevent infinite nesting.
+ */
+const STAGE_DEFS = {
+  tests: {
+    command: 'node tests/run-all.js',
+    skipIf: () =>
+      process.env.MINDFORGE_VERIFICATION_ACTIVE === '1' ||
+      process.env.NODE_ENV === 'test',
+  },
+  lint: {
+    command: 'npx eslint . --max-warnings=0',
+    skipIf: null,
+  },
+  audit: {
+    command: 'node bin/verify-audit.js',
+    skipIf: null,
+  },
+  typecheck: {
+    command: 'npx tsc --noEmit',
+    skipIf: (cwd) => !fs.existsSync(path.join(cwd, 'tsconfig.json')),
+  },
+};
+
+/**
+ * Run a single stage, returning a structured result object.
+ */
+function executeStage(name, cwd) {
+  const def = STAGE_DEFS[name];
+  if (!def) {
+    return { name, status: 'skip', durationMs: 0, output: `Unknown stage: ${name}` };
+  }
+
+  // Check skip condition
+  if (def.skipIf && def.skipIf(cwd)) {
+    return { name, status: 'skip', durationMs: 0, output: '' };
+  }
+
+  const start = Date.now();
+  let output = '';
+  let status = 'pass';
+
+  try {
+    const env = Object.assign({}, process.env, {
+      MINDFORGE_VERIFICATION_ACTIVE: '1',
+    });
+    const result = execSync(def.command, {
+      cwd,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 120000,
+      env,
+    });
+    output = (result || '').slice(0, MAX_OUTPUT_LENGTH);
+  } catch (err) {
+    status = 'fail';
+    const stdout = err.stdout || '';
+    const stderr = err.stderr || '';
+    output = (stdout + '\n' + stderr).trim().slice(0, MAX_OUTPUT_LENGTH);
+  }
+
+  const durationMs = Date.now() - start;
+  return { name, status, durationMs, output };
+}
+
+/**
+ * Run verification across multiple stages.
+ * @param {{ cwd: string, stages: string[] }} opts
+ * @returns {Promise<object>} Structured verification result
+ */
+async function runVerification({ cwd, stages }) {
+  const resolvedCwd = path.resolve(cwd);
+  const results = [];
+
+  for (const stageName of stages) {
+    const result = executeStage(stageName, resolvedCwd);
+    results.push(result);
+  }
+
+  const passed = results.filter(s => s.status === 'pass').length;
+  const failed = results.filter(s => s.status === 'fail').length;
+  const skipped = results.filter(s => s.status === 'skip').length;
+  const totalDurationMs = results.reduce((sum, s) => sum + s.durationMs, 0);
+
+  return {
+    stages: results,
+    summary: { passed, failed, skipped, totalDurationMs },
+    timestamp: new Date().toISOString(),
+  };
+}
+
+/**
+ * Format a verification result as a markdown report.
+ * @param {object} result — output from runVerification
+ * @returns {string} Markdown report
+ */
+function formatReport(result) {
+  const statusEmoji = { pass: '✅', fail: '❌', skip: '⏭️' };
+  const lines = [];
+
+  lines.push('# Verification Report');
+  lines.push('');
+  lines.push(`**Timestamp:** ${result.timestamp}`);
+  lines.push('');
+  lines.push('| Stage | Status | Duration |');
+  lines.push('|-------|--------|----------|');
+
+  for (const stage of result.stages) {
+    const emoji = statusEmoji[stage.status] || '?';
+    const duration = stage.durationMs > 0 ? `${stage.durationMs}ms` : '-';
+    lines.push(`| ${stage.name} | ${emoji} ${stage.status} | ${duration} |`);
+  }
+
+  lines.push('');
+  lines.push(`**Summary:** ${result.summary.passed} passed, ${result.summary.failed} failed, ${result.summary.skipped} skipped (${result.summary.totalDurationMs}ms total)`);
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+module.exports = { runVerification, formatReport };

package/bin/engine/verify-cli.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * verify-cli.js — Entrypoint for the `verify` CLI command.
+ * Calls the unified verification runner across all stages and writes
+ * the formatted report to .planning/VERIFICATION.md.
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { runVerification, formatReport } = require('./verification-runner');
+
+const STAGES = ['tests', 'lint', 'audit', 'typecheck'];
+const CWD = process.env.MINDFORGE_ROOT || path.resolve(__dirname, '../..');
+
+async function main() {
+  const planningDir = path.join(CWD, '.planning');
+  if (!fs.existsSync(planningDir)) {
+    fs.mkdirSync(planningDir, { recursive: true });
+  }
+
+  const result = await runVerification({ cwd: CWD, stages: STAGES });
+  const report = formatReport(result);
+
+  fs.writeFileSync(path.join(planningDir, 'VERIFICATION.md'), report);
+  process.stdout.write(report + '\n');
+  process.exit(result.summary.failed > 0 ? 1 : 0);
+}
+
+main().catch(err => {
+  console.error('Verification runner failed:', err.message);
+  process.exit(1);
+});

package/bin/eval/eval-harness.js

@@ -0,0 +1,82 @@
+'use strict';
+
+/**
+ * Recall@K — fraction of relevant items found in the top-k retrieved results.
+ * @param {string[]} retrieved - IDs in ranked order
+ * @param {string[]} relevant - ground-truth relevant IDs
+ * @param {number} k - cutoff
+ * @returns {number} recall in [0, 1]
+ */
+function recallAtK(retrieved, relevant, k) {
+  if (relevant.length === 0) return 0;
+  const topK = retrieved.slice(0, k);
+  const relevantSet = new Set(relevant);
+  const found = topK.filter(id => relevantSet.has(id)).length;
+  return found / relevant.length;
+}
+
+/**
+ * nDCG (Normalized Discounted Cumulative Gain) with graded relevance.
+ * @param {string[]} retrieved - IDs in ranked order
+ * @param {Object.<string, number>} relevanceMap - {id: grade} where grade is 0-3
+ * @param {number} k - cutoff
+ * @returns {number} nDCG in [0, 1]
+ */
+function ndcg(retrieved, relevanceMap, k) {
+  const topK = retrieved.slice(0, k);
+
+  // DCG = Σ (2^rel_i - 1) / log2(i + 2) for i = 0..k-1
+  const dcg = topK.reduce((sum, id, i) => {
+    const rel = relevanceMap[id] || 0;
+    return sum + (Math.pow(2, rel) - 1) / Math.log2(i + 2);
+  }, 0);
+
+  // IDCG — ideal ordering: sort all relevance grades descending, take top-k
+  const idealGrades = Object.values(relevanceMap)
+    .filter(g => g > 0)
+    .sort((a, b) => b - a)
+    .slice(0, k);
+
+  const idcg = idealGrades.reduce((sum, rel, i) => {
+    return sum + (Math.pow(2, rel) - 1) / Math.log2(i + 2);
+  }, 0);
+
+  if (idcg === 0) return 0;
+  return dcg / idcg;
+}
+
+/**
+ * Run a full evaluation over a golden set of queries.
+ * @param {Object} opts
+ * @param {Array<{query: string, relevant: string[]}>} opts.goldenSet
+ * @param {function(string): string[]} opts.retriever
+ * @param {number} opts.k
+ * @returns {Promise<{meanRecallAtK: number, meanNDCG: number, perQuery: Array}>}
+ */
+async function runEval({ goldenSet, retriever, k }) {
+  const perQuery = [];
+
+  for (const { query, relevant } of goldenSet) {
+    const retrieved = await Promise.resolve(retriever(query));
+
+    // Binary relevance map: relevant items get grade 1, others 0
+    const relevanceMap = {};
+    for (const id of relevant) {
+      relevanceMap[id] = 1;
+    }
+
+    const recall = recallAtK(retrieved, relevant, k);
+    const ndcgScore = ndcg(retrieved, relevanceMap, k);
+
+    perQuery.push({ query, recall, ndcg: ndcgScore, retrieved });
+  }
+
+  if (perQuery.length === 0) return { meanRecallAtK: 0, meanNDCG: 0, perQuery: [] };
+
+  const meanRecallAtK = perQuery.reduce((s, q) => s + q.recall, 0) / perQuery.length;
+  const meanNDCG = perQuery.reduce((s, q) => s + q.ndcg, 0) / perQuery.length;
+
+  return { meanRecallAtK, meanNDCG, perQuery };
+}
+
+module.exports = { recallAtK, ndcg, runEval };

package/bin/eval/golden-set-retrieval.json

@@ -0,0 +1,46 @@
+{
+  "description": "Golden set for retrieval quality evaluation. Each entry has a natural-language query and the IDs of documents that SHOULD be retrieved.",
+  "version": "1.0.0",
+  "queries": [
+    {
+      "query": "how does the audit hash chain work",
+      "relevant": ["audit-hash", "audit-verifier", "verify-audit"]
+    },
+    {
+      "query": "what model should I use for a security-sensitive task",
+      "relevant": ["difficulty-scorer", "model-router", "pricing-registry", "trust-boundaries"]
+    },
+    {
+      "query": "how does wave execution and parallel orchestration work",
+      "relevant": ["wave-executor", "swarm-controller", "auto-executor"]
+    },
+    {
+      "query": "how do I track token costs and budget enforcement",
+      "relevant": ["cost-tracker", "token-ledger", "budget-enforcer", "finops-hub"]
+    },
+    {
+      "query": "how does the knowledge store persist and retrieve entries",
+      "relevant": ["knowledge-store", "knowledge-graph-protocol", "shard-controller"]
+    },
+    {
+      "query": "what happens during council consensus and synthesis",
+      "relevant": ["council-protocol", "synthesis-engine", "council-templates"]
+    },
+    {
+      "query": "how do instincts get captured and promoted to skills",
+      "relevant": ["capture-engine", "promotion-engine", "instinct-schema", "skill-registry"]
+    },
+    {
+      "query": "what verification checks run before marking a task complete",
+      "relevant": ["verification-pipeline", "trust-verifier", "policy-engine"]
+    },
+    {
+      "query": "how does the autonomous stuck detector recover failed tasks",
+      "relevant": ["stuck-detector", "node-repair", "steering-manager", "progress-reporter"]
+    },
+    {
+      "query": "how are hooks triggered and what security gates exist pre-commit",
+      "relevant": ["trust-gate-hook", "instinct-capture-hook", "policy-gate-hardened", "impact-analyzer"]
+    }
+  ]
+}

package/bin/governance/audit-hash.js

@@ -0,0 +1,12 @@
+'use strict';
+const crypto = require('crypto');
+/**
+ * Canonical audit hash material. MUST be the single source of truth for both
+ * the writer (pre-_hash entry) and the verifier (entry with _hash stripped).
+ * Hashes {...entry, previous_hash} — entry must NOT contain _hash.
+ */
+function hashAuditEntry(entryWithoutHash, previousHash) {
+  const material = JSON.stringify({ ...entryWithoutHash, previous_hash: previousHash });
+  return crypto.createHash('sha256').update(material).digest('hex');
+}
+module.exports = { hashAuditEntry };

package/bin/governance/audit-verifier.js

@@ -0,0 +1,60 @@
+'use strict';
+/**
+ * MindForge — Audit chain verifier (UC-04). Fail-closed: any break => valid:false.
+ *
+ * Walks the JSONL audit log line-by-line and re-derives each entry's hash from its
+ * content plus the prior entry's hash. The chain is valid only if EVERY link holds:
+ *   1. entry.previous_hash matches the running previousHash (null for the first entry)
+ *   2. entry._hash equals sha256({...entry-without-_hash, previous_hash})
+ *
+ * CRITICAL INVARIANT: hashEntry() here MUST produce byte-identical material to the
+ * writer (bin/autonomous/audit-writer.js). The writer hashes {...e, previous_hash}
+ * where `e` has no `_hash`. The stored entry is {...e, previous_hash, _hash}; stripping
+ * `_hash` via destructuring yields {...e, previous_hash} with the SAME key insertion
+ * order, so {...rest, previous_hash} reproduces the writer's material exactly.
+ */
+const fs = require('fs');
+const { hashAuditEntry } = require('./audit-hash');
+
+/**
+ * Re-derives an entry's chained hash. Excludes `_hash` from the material by
+ * stripping it, then delegating to the canonical {@link hashAuditEntry} so the
+ * writer and verifier share ONE hasher (no material drift possible).
+ * @param {object} entry — stored entry (may include `_hash`, which is stripped)
+ * @param {string|null} previousHash — prior entry's `_hash` (null for the first link)
+ * @returns {string} hex-encoded SHA-256 digest
+ */
+function hashEntry(entry, previousHash) {
+  const { _hash, ...rest } = entry; // exclude _hash from material
+  return hashAuditEntry(rest, previousHash);
+}
+
+/**
+ * Verifies the integrity of a hash-chained audit log. Fail-closed.
+ * @param {string} auditPath — path to the AUDIT.jsonl file
+ * @returns {{ valid: boolean, count: number, brokenAt?: number, reason?: string }}
+ */
+function verifyAuditChain(auditPath) {
+  let lines;
+  try { lines = fs.readFileSync(auditPath, 'utf8').split('\n').filter(Boolean); }
+  catch (e) { return { valid: false, count: 0, brokenAt: 0, reason: `unreadable: ${e.message}` }; }
+
+  let previousHash = null;
+  for (let i = 0; i < lines.length; i++) {
+    let entry;
+    try { entry = JSON.parse(lines[i]); }
+    catch { return { valid: false, count: lines.length, brokenAt: i, reason: 'unparseable line' }; }
+
+    if (entry.previous_hash !== previousHash) {
+      return { valid: false, count: lines.length, brokenAt: i, reason: 'previous_hash mismatch' };
+    }
+    const expected = hashEntry(entry, previousHash);
+    if (entry._hash !== expected) {
+      return { valid: false, count: lines.length, brokenAt: i, reason: 'hash mismatch (entry mutated)' };
+    }
+    previousHash = entry._hash;
+  }
+  return { valid: true, count: lines.length };
+}
+
+module.exports = { verifyAuditChain };

package/bin/governance/policy-engine.js

@@ -92,10 +92,14 @@ class PolicyEngine {
             return verdict;
           }
 
-          // [ENTERPRISE] Tier 3 Reasoning/PQ Proof Bypass
+          // [ENTERPRISE] Tier 3 Sovereign Proof Bypass (fail-closed).
+          // A blast-radius override demands a CRYPTOGRAPHIC proof. Only a
+          // pq_proof verified via verifyZKProof may authorize the bypass.
+          // intent.reasoning_proof is free-form text validated nowhere, so it
+          // MUST NOT, on its own, grant an override (UC-22 authz bypass fix).
           if (intent.tier >= 3 && (intent.reasoning_proof || intent.pq_proof)) {
              const quantumCrypto = require('./quantum-crypto');
-             let isProofValid = true;
+             let isProofValid = false; // fail-closed: deny unless a real proof verifies
 
              if (intent.pq_proof) {
                const zkResult = quantumCrypto.verifyZKProof(intent.pq_proof, intent.id);
@@ -106,12 +110,21 @@ class PolicyEngine {
              }
 
              if (isProofValid) {
-                console.log(`[APO-BYPASS] [${requestId}] Tier 3 'Sovereign Proof' verified (${intent.pq_proof ? 'ZK-PQ' : 'Standard'}). Overriding Blast Radius limit.`);
+                console.log(`[APO-BYPASS] [${requestId}] Tier 3 'Sovereign Proof' verified (ZK-PQ). Overriding Blast Radius limit.`);
                 // Continue to permit check
-             } else {
+             } else if (intent.pq_proof) {
                 verdict = { verdict: 'DENY', reason: 'ZK proof verification failed. Configure a verifier module or provide a valid proof.', requestId };
                 this.logAudit(intent, impactScore, verdict);
                 return verdict;
+             } else {
+                // Only a reasoning_proof was supplied — not a cryptographic proof.
+                verdict = {
+                  verdict: 'DENY',
+                  reason: 'reasoning_proof is not a cryptographic proof; provide a valid pq_proof / Sovereign Proof for blast-radius override.',
+                  requestId
+                };
+                this.logAudit(intent, impactScore, verdict);
+                return verdict;
              }
           } else {
             verdict = { 

package/bin/governance/quantum-crypto.js

@@ -10,20 +10,59 @@
 const crypto = require('node:crypto');
 const configManager = require('./config-manager');
 
+/**
+ * Honest-disclosure guard message. The signatures produced by this module are
+ * SIMULATED Dilithium-5 (base64(SHA3 + random) — NOT real ML-DSA/FIPS-204
+ * lattice crypto). They must NEVER sit on the live trust path silently. The
+ * simulated implementation is preserved for demonstration only and is gated
+ * behind an explicit, opt-in flag.
+ */
+const PQC_DEMO_DISABLED_MSG =
+  'PQC demo disabled — set experimental.pqc_demo=true to use simulated lattice crypto (NOT for production trust)';
+
 class QuantumCrypto {
   constructor() {
     this.providerId = configManager.get('security.provider', 'simulated-lattice');
-    this.pqasEnabled = configManager.get('security.pqas_enabled', true);
+    // UC-24: simulated PQC is OFF the live trust path by default. Real PQC has
+    // not shipped. The simulated path is gated SOLELY behind the explicit
+    // experimental.pqc_demo opt-in (read fresh via isPqcDemoEnabled), so there
+    // is exactly one switch controlling the simulated minter. The legacy
+    // security.pqas_enabled flag is retained for provider metadata only and
+    // MUST NOT independently gate minting (see getProvider).
+    this.pqasEnabled = configManager.get('security.pqas_enabled', false);
+  }
+
+  /**
+   * Returns true only when the operator has explicitly opted into the SIMULATED
+   * post-quantum demo. Read fresh from config so a runtime toggle is honored.
+   * @returns {boolean}
+   */
+  isPqcDemoEnabled() {
+    return configManager.get('experimental.pqc_demo', false) === true;
+  }
+
+  /**
+   * Hard gate: throws unless the operator has explicitly enabled the simulated
+   * PQC demo. Prevents simulated (false-assurance) signatures from silently
+   * landing on the live trust path.
+   */
+  _assertPqcDemoEnabled() {
+    if (!this.isPqcDemoEnabled()) {
+      throw new Error(PQC_DEMO_DISABLED_MSG);
+    }
   }
 
   /**
    * Returns the current active crypto provider.
    */
   getProvider() {
-    // In v7, this would resolve to a real provider like 'oqs-provider.js'
+    // In v7, this would resolve to a real provider like 'oqs-provider.js'.
+    // Read pqas_enabled FRESH from config (not the constructor cache) for
+    // symmetry with the demo gate. This is metadata only — it does NOT gate
+    // minting; experimental.pqc_demo is the single source of truth for that.
     return {
       id: this.providerId,
-      pqas_enabled: this.pqasEnabled,
+      pqas_enabled: configManager.get('security.pqas_enabled', false),
       algorithm: 'Dilithium-5'
     };
   }
@@ -32,7 +71,10 @@ class QuantumCrypto {
    * Generates a key pair using the configured PQ provider.
    */
   async generateLatticeKeyPair() {
-    if (!this.pqasEnabled) throw new Error('PQAS is disabled in configuration.');
+    // UC-24: simulated keys are demo-only. The SINGLE gate is the fresh-read
+    // experimental.pqc_demo flag — enabling it is sufficient to mint, and
+    // disabling it fails closed. security.pqas_enabled does NOT gate this.
+    this._assertPqcDemoEnabled();
 
     // Simulate high-entropy lattice seeds
     const seed = crypto.randomBytes(64).toString('hex');
@@ -53,7 +95,11 @@ class QuantumCrypto {
    * @returns {{ signature: string, simulated: true, algorithm: string }}
    */
   async signPQ(data, privateKey) {
-    if (!this.pqasEnabled) throw new Error('PQAS is disabled.');
+    // UC-24: never produce a simulated (false-assurance) signature on the live
+    // trust path. The SINGLE gate is the fresh-read experimental.pqc_demo flag
+    // (same flag _selectProvider routes on) — security.pqas_enabled does NOT
+    // independently block signing.
+    this._assertPqcDemoEnabled();
     if (!privateKey.startsWith('mfq7_dilithium5_priv_')) {
       throw new Error('Invalid Post-Quantum private key format.');
     }
@@ -92,19 +138,27 @@ class QuantumCrypto {
   }
 
   /**
-   * Generates a simulated ZK-Proof of policy adherence.
-   * This mimics a SNARK where the agent proves it ran the PolicyEngine rules.
+   * Generates a SIMULATED ZK-Proof of policy adherence.
+   * This mimics a SNARK where the agent proves it ran the PolicyEngine rules,
+   * but it is NOT a real zero-knowledge proof. The returned token is explicitly
+   * stamped with a `sim` marker (zkp_v1_sim_...) so downstream code and audit
+   * logs can never mistake it for a real SNARK. It remains inert by default —
+   * verifyZKProof DENYs unless an external verifier module is configured.
+   * @returns {string} A simulated ZK-proof token prefixed `zkp_v1_sim_`.
    */
   generateZKProof(intent, result) {
     const proofPayload = JSON.stringify({
       intent: intent.id,
       verdict: result.verdict,
       timestamp: Date.now(),
-      entropy: crypto.randomBytes(16).toString('hex')
+      entropy: crypto.randomBytes(16).toString('hex'),
+      simulated: true
     });
 
     const hash = crypto.createHash('sha256').update(proofPayload).digest('hex');
-    return `zkp_v1_${hash}_${crypto.randomBytes(32).toString('base64')}`;
+    // `sim` marker is embedded AFTER the `zkp_v1_` prefix so the existing
+    // format check (startsWith 'zkp_v1_') and any external verifier still work.
+    return `zkp_v1_sim_${hash}_${crypto.randomBytes(32).toString('base64')}`;
   }
 
   verifyZKProof(proof, intentId) {

package/bin/governance/ztai-archiver.js

@@ -20,19 +20,35 @@ class ZTAIArchiver {
    * @param {string} archiverDid - The DID of the archiver (e.g., Release Manager)
    * @returns {Promise<Object>} - The signed manifest
    */
-  async generateManifest(entries, archiverDid) {
-    if (!entries || entries.length === 0) return null;
-
-    // 1. Calculate the Merkle-like root hash of the block
-    const blockHashes = entries.map(e => 
+  /**
+   * Computes the cumulative-hash-chain "Merkle root" for a block of entries.
+   *
+   * This is the SINGLE source of truth for the root algorithm. Both
+   * generateManifest() (write path) and verifyIntegrity() (read/verify path)
+   * MUST call this so the two can never drift — a drift would re-introduce the
+   * false-assurance defect (audit finding #15 / UC-22).
+   *
+   * @param {Array<Object>} entries - Ordered block of audit entries.
+   * @returns {string} - The cumulative SHA-256 hash chain (hex).
+   */
+  _computeMerkleRoot(entries) {
+    const blockHashes = entries.map(e =>
       crypto.createHash('sha256').update(JSON.stringify(e)).digest('hex')
     );
-    
-    // Simple cumulative hash chain as a Merkle Root equivalent
+
+    // Simple cumulative hash chain as a Merkle Root equivalent.
     let cumulativeHash = '';
     for (const h of blockHashes) {
       cumulativeHash = crypto.createHash('sha256').update(cumulativeHash + h).digest('hex');
     }
+    return cumulativeHash;
+  }
+
+  async generateManifest(entries, archiverDid) {
+    if (!entries || entries.length === 0) return null;
+
+    // 1. Calculate the Merkle-like root hash of the block.
+    const cumulativeHash = this._computeMerkleRoot(entries);
 
     const manifestMetadata = {
       blockStart: entries[0].timestamp,
@@ -94,8 +110,57 @@ class ZTAIArchiver {
       throw new Error(`CRITICAL: Manifest signature invalid for ${manifestPath}`);
     }
 
-    // 2. Recalculate and Verify Merkle Root (Simulated)
-    // In a real environment, this would compare against the actual AUDIT.jsonl data slices.
+    // 2. Recalculate and Verify Merkle Root against the LIVE AUDIT.jsonl.
+    //
+    // A valid signature only proves the manifest itself is authentic; it says
+    // NOTHING about whether the underlying audit log still matches. We must
+    // recompute the root from disk and compare — anything less is false
+    // assurance (audit finding #15 / UC-22). Fail-closed on every error path:
+    // a missing/unreadable log MUST NOT pass.
+    let auditData;
+    try {
+      auditData = await fs.readFile(this.auditPath, 'utf8');
+    } catch (err) {
+      throw new Error(`CRITICAL: Audit log unreadable at ${this.auditPath} — cannot verify integrity (${err.message})`);
+    }
+
+    let allEntries;
+    try {
+      allEntries = auditData
+        .split('\n')
+        .filter(l => l.trim() !== '')
+        .map(l => JSON.parse(l));
+    } catch (err) {
+      throw new Error(`CRITICAL: Audit log corrupted / unparseable for ${manifestPath} (${err.message})`);
+    }
+
+    // Select the block this manifest covers: entries whose timestamp falls
+    // within [blockStart, blockEnd] inclusive.
+    const start = Date.parse(manifest.blockStart);
+    const end = Date.parse(manifest.blockEnd);
+    const blockEntries = allEntries.filter(e => {
+      const ts = Date.parse(e.timestamp);
+      return ts >= start && ts <= end;
+    });
+
+    // Sanity-check the selected count against the manifest. A mismatch means
+    // entries were added or deleted within the covered window.
+    if (blockEntries.length !== manifest.entryCount) {
+      throw new Error(
+        'CRITICAL: Audit log tampering detected — block entry count mismatch ' +
+        `(manifest=${manifest.entryCount}, found=${blockEntries.length}) for ${manifestPath}`
+      );
+    }
+
+    // Recompute the root with the SAME algorithm used at archive time.
+    const recomputedRoot = this._computeMerkleRoot(blockEntries);
+    if (recomputedRoot !== manifest.merkleRoot) {
+      throw new Error(
+        `CRITICAL: Audit log tampering detected — Merkle root mismatch for ${manifestPath} ` +
+        `(expected=${manifest.merkleRoot}, recomputed=${recomputedRoot}).`
+      );
+    }
+
     console.log(`[ZTAI-ARCHIVER] Integrity Verified for block ending ${manifest.blockEnd}`);
     return true;
   }