monomind 1.18.15 → 2.0.0

package/packages/@monomind/cli/dist/src/mcp-tools/coherence/spectral-analyze.js

@@ -2,9 +2,8 @@
  * Spectral Analysis Tool - pr_spectral_analyze
  *
  * Analyzes stability of systems using spectral graph theory.
- * Computes eigenvalues, spectral gap, and stability metrics.
- *
- * Uses SpectralEngine from prime-radiant-advanced-wasm
+ * Computes eigenvalues via power iteration with Hotelling deflation,
+ * spectral gap, and stability metrics from the graph Laplacian.
  */
 import { SpectralInputSchema, successResult, errorResult, } from './types.js';
 // Default logger
@@ -15,14 +14,32 @@ const defaultLogger = {
     error: (msg, meta) => console.error(`[pr_spectral_analyze] ${msg}`, meta),
 };
 /**
- * Power iteration method for finding dominant eigenvalue
+ * Simple deterministic hash to seed initial vectors reproducibly from matrix content
+ */
+function matrixHash(matrix) {
+    let hash = 0;
+    for (let i = 0; i < matrix.length; i++) {
+        for (let j = 0; j < matrix[i].length; j++) {
+            // Combine with a simple LCG-style mixing
+            hash = ((hash * 1103515245 + 12345) & 0x7fffffff) ^ (matrix[i][j] * 1000003 | 0);
+        }
+    }
+    return hash;
+}
+/**
+ * Power iteration method for finding dominant eigenvalue.
+ * Returns both the eigenvalue and the converged eigenvector.
  */
-function powerIteration(matrix, maxIterations = 100, tolerance = 1e-10) {
+function powerIteration(matrix, maxIterations = 100, tolerance = 1e-10, seed) {
     const n = matrix.length;
     if (n === 0)
-        return 0;
-    // Initialize random vector
-    let v = new Array(n).fill(0).map(() => Math.random());
+        return { eigenvalue: 0, eigenvector: [] };
+    // Initialize with deterministic vector seeded from matrix content
+    let s = seed ?? matrixHash(matrix);
+    let v = new Array(n).fill(0).map(() => {
+        s = (s * 1103515245 + 12345) & 0x7fffffff;
+        return (s / 0x7fffffff) * 2 - 1;
+    });
     let eigenvalue = 0;
     for (let iter = 0; iter < maxIterations; iter++) {
         // Multiply matrix by vector
@@ -44,7 +61,7 @@ function powerIteration(matrix, maxIterations = 100, tolerance = 1e-10) {
         // Check convergence
         const newEigenvalue = maxComponent;
         if (Math.abs(newEigenvalue - eigenvalue) < tolerance) {
-            return newEigenvalue;
+            return { eigenvalue: newEigenvalue, eigenvector: v };
         }
         eigenvalue = newEigenvalue;
         // Normalize
@@ -52,38 +69,40 @@ function powerIteration(matrix, maxIterations = 100, tolerance = 1e-10) {
             v[i] = w[i] / maxComponent;
         }
     }
-    return eigenvalue;
+    return { eigenvalue, eigenvector: v };
 }
 /**
- * Compute approximate eigenvalues using QR iteration (simplified)
- * For production, consider using a proper numerical library
+ * Compute eigenvalues via repeated power-iteration with Hotelling deflation.
+ * Returns only eigenvalues actually computed (up to min(n, maxCount)).
+ * For production, consider using a proper numerical library.
  */
-function computeEigenvalues(matrix) {
+function computeEigenvalues(matrix, maxCount = 10) {
     const n = matrix.length;
     if (n === 0)
         return [];
     if (n === 1)
         return [matrix[0][0]];
-    // For small matrices, use characteristic polynomial roots (simplified)
-    // For larger matrices, use power iteration for top k eigenvalues
     const eigenvalues = [];
-    // Get dominant eigenvalue
-    const lambda1 = powerIteration(matrix);
-    eigenvalues.push(lambda1);
-    // For spectral analysis, we mainly need the top eigenvalues and spectral gap
-    // Use deflation to get second eigenvalue
-    if (n > 1) {
-        // Simplified: estimate second eigenvalue from trace
-        let trace = 0;
+    // Work on a copy so deflation doesn't mutate the original
+    let current = matrix.map(row => [...row]);
+    const count = Math.min(n, maxCount);
+    for (let k = 0; k < count; k++) {
+        const { eigenvalue, eigenvector } = powerIteration(current, 200, 1e-10, matrixHash(current) + k);
+        // If power iteration didn't converge to anything meaningful, stop
+        if (Math.abs(eigenvalue) < 1e-12)
+            break;
+        eigenvalues.push(eigenvalue);
+        // Hotelling deflation: subtract lambda * v * v^T from the matrix
+        // to remove the dominant eigenvalue and find the next one
+        let vNorm = 0;
+        for (let i = 0; i < n; i++)
+            vNorm += eigenvector[i] * eigenvector[i];
+        if (vNorm < 1e-12)
+            break;
         for (let i = 0; i < n; i++) {
-            trace += matrix[i][i];
-        }
-        // Second eigenvalue approximation
-        const lambda2Approx = (trace - lambda1) / (n - 1);
-        eigenvalues.push(lambda2Approx);
-        // Add remaining approximate eigenvalues
-        for (let i = 2; i < Math.min(n, 10); i++) {
-            eigenvalues.push(lambda2Approx * (1 - i * 0.1)); // Decreasing approximation
+            for (let j = 0; j < n; j++) {
+                current[i][j] -= eigenvalue * (eigenvector[i] * eigenvector[j]) / vNorm;
+            }
         }
     }
     return eigenvalues.sort((a, b) => Math.abs(b) - Math.abs(a));
@@ -264,7 +283,7 @@ async function handler(input, context) {
  */
 export const spectralAnalyzeTool = {
     name: 'pr_spectral_analyze',
-    description: 'Analyze stability using spectral graph theory. Computes eigenvalues, spectral gap, and stability metrics. Uses SpectralEngine for mathematical validation of system stability.',
+    description: 'Analyze stability using spectral graph theory. Computes eigenvalues via power iteration with Hotelling deflation, spectral gap, and stability metrics from the graph Laplacian.',
     category: 'spectral',
     version: '0.1.3',
     tags: ['spectral', 'eigenvalues', 'stability', 'graph-theory', 'ai-interpretability'],

package/packages/@monomind/cli/dist/src/mcp-tools/coherence/types.d.ts

@@ -162,15 +162,12 @@ export declare const CausalInputSchema: z.ZodObject<{
 }>;
 export type CausalInput = z.infer<typeof CausalInputSchema>;
 export interface CausalResult {
-    effect: number;
     confounders: string[];
     interventionValid: boolean;
     backdoorPaths: string[][];
-    confidence: number;
 }
 export interface CausalOutput {
-    effect: number;
-    confidence: number;
+    identifiability: number;
     backdoorPaths: string[];
     details: {
         confounders: string[];
@@ -240,8 +237,8 @@ export interface ConsensusOutput {
     details: {
         agreementRatio: number;
         coherenceEnergy: number;
-        spectralStability: boolean;
-        spectralGap: number;
+        connectivityStable: boolean;
+        degreeRatio: number;
         interpretation: string;
         agentCount: number;
     };
@@ -352,7 +349,6 @@ export interface TopologyOutput {
         interpretation: {
             b0: string;
             b1: string;
-            b2: string;
         };
         vertexCount: number;
         maxDimension: number;
@@ -375,19 +371,19 @@ export declare const MemoryGateInputSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     key: string;
     value?: unknown;
+    existingVectors?: number[][] | undefined;
     thresholds?: {
         warn: number;
         reject: number;
     } | undefined;
-    existingVectors?: number[][] | undefined;
 }, {
     key: string;
     value?: unknown;
+    existingVectors?: number[][] | undefined;
     thresholds?: {
         warn?: number | undefined;
         reject?: number | undefined;
     } | undefined;
-    existingVectors?: number[][] | undefined;
 }>;
 export type MemoryGateInput = z.infer<typeof MemoryGateInputSchema>;
 export interface MemoryGateOutput {
@@ -427,7 +423,8 @@ export declare function trackPerformance<T>(operationName: string, operation: ()
     metrics: PerformanceMetrics;
 }>;
 /**
- * Calculate cosine similarity between two vectors
+ * Cosine similarity — re-exported from shared utility.
+ * Callers that already import from this module continue to work unchanged.
  */
-export declare function cosineSimilarity(a: number[] | Float32Array, b: number[] | Float32Array): number;
+export { cosineSimilarity } from '../../utils/cosine-similarity.js';
 //# sourceMappingURL=types.d.ts.map

package/packages/@monomind/cli/dist/src/mcp-tools/coherence/types.js

@@ -137,23 +137,8 @@ export function trackPerformance(operationName, operation) {
     });
 }
 /**
- * Calculate cosine similarity between two vectors
+ * Cosine similarity — re-exported from shared utility.
+ * Callers that already import from this module continue to work unchanged.
  */
-export function cosineSimilarity(a, b) {
-    if (a.length !== b.length) {
-        throw new Error(`Vector length mismatch: ${a.length} vs ${b.length}`);
-    }
-    let dotProduct = 0;
-    let normA = 0;
-    let normB = 0;
-    for (let i = 0; i < a.length; i++) {
-        dotProduct += a[i] * b[i];
-        normA += a[i] * a[i];
-        normB += b[i] * b[i];
-    }
-    const denominator = Math.sqrt(normA) * Math.sqrt(normB);
-    if (denominator === 0)
-        return 0;
-    return dotProduct / denominator;
-}
+export { cosineSimilarity } from '../../utils/cosine-similarity.js';
 //# sourceMappingURL=types.js.map

package/packages/@monomind/cli/dist/src/mcp-tools/embeddings-tools.js

@@ -6,6 +6,7 @@
  */
 import { existsSync, readFileSync, statSync, writeFileSync, renameSync, mkdirSync } from 'fs';
 import { join, resolve } from 'path';
+import { cosineSimilarity } from '../utils/cosine-similarity.js';
 // Configuration paths
 const CONFIG_DIR = '.monomind';
 const EMBEDDINGS_CONFIG = 'embeddings.json';
@@ -125,13 +126,6 @@ function poincareDistance(a, b, curvature) {
     const delta = 2 * diffSq / (denom + 1e-15);
     return (1 / Math.sqrt(c)) * Math.acosh(1 + delta);
 }
-// Cosine similarity
-function cosineSimilarity(a, b) {
-    const dot = a.reduce((sum, _, i) => sum + a[i] * b[i], 0);
-    const normA = Math.sqrt(a.reduce((sum, x) => sum + x * x, 0));
-    const normB = Math.sqrt(b.reduce((sum, x) => sum + x * x, 0));
-    return dot / (normA * normB + 1e-15);
-}
 export const embeddingsTools = [
     {
         name: 'embeddings_init',

package/packages/@monomind/cli/dist/src/mcp-tools/graphify-tools.js

@@ -4,9 +4,9 @@
  * All graphify_* tools are deprecated. They proxy to monograph_* tools.
  * Will be removed in next major release.
  */
-import { monographTools } from './monograph-tools.js';
+import { allMonographTools } from './monograph-tools.js';
 function findMonographTool(name) {
-    const tool = monographTools.find(t => t.name === name);
+    const tool = allMonographTools.find(t => t.name === name);
     if (!tool)
         throw new Error(`[monograph] Tool ${name} not found`);
     return tool;

package/packages/@monomind/cli/dist/src/mcp-tools/guidance-tools.js

@@ -85,9 +85,9 @@ const CAPABILITY_CATALOG = {
     },
     'intelligence-learning': {
         name: 'Intelligence & Learning',
-        description: 'Neural pattern training (SONA), RL loops, Flash Attention, EWC++ consolidation.',
+        description: 'Pattern storage and cosine-similarity search (SONA/ReasoningBank) backed by real embeddings.',
         tools: ['neural_train', 'neural_predict', 'neural_status', 'neural_patterns', 'neural_optimize'],
-        commands: ['neural train', 'neural predict', 'neural status', 'neural patterns', 'neural optimize'],
+        commands: [],
         agents: ['sona-learning-optimizer', 'safla-neural'],
         skills: ['reasoningbank-intelligence', 'memory-reasoningbank'],
         whenToUse: 'When optimizing agent routing, training patterns from outcomes, or adaptive learning.',
@@ -144,13 +144,13 @@ const CAPABILITY_CATALOG = {
         whenToUse: 'When working with GitHub repos, PRs, issues, releases, or CI/CD pipelines.',
     },
     'session-workflow': {
-        name: 'Session & Workflow',
-        description: 'Session state management, workflow execution, task lifecycle, and daemon scheduling.',
-        tools: ['session_start', 'session_end', 'session_restore', 'session_list', 'workflow_execute', 'workflow_create', 'task_create', 'task_assign', 'task_status'],
-        commands: ['session start', 'session end', 'session restore', 'workflow execute', 'workflow create', 'task create', 'daemon start', 'daemon stop'],
+        name: 'Session & Tasks',
+        description: 'Session state management and task lifecycle.',
+        tools: ['session_start', 'session_end', 'session_restore', 'session_list', 'task_create', 'task_assign', 'task_status'],
+        commands: ['session start', 'session end', 'session restore', 'task create'],
         agents: [],
         skills: [],
-        whenToUse: 'When managing long-running sessions, executing workflow templates, or scheduling tasks.',
+        whenToUse: 'When managing long-running sessions or scheduling tasks.',
     },
     'embeddings-vectors': {
         name: 'Embeddings & Vector Search',
@@ -170,15 +170,6 @@ const CAPABILITY_CATALOG = {
         skills: ['verification-quality'],
         whenToUse: 'When analyzing code quality, diffs, coverage gaps, or dependency graphs.',
     },
-    'sparc-methodology': {
-        name: 'SPARC Methodology',
-        description: 'Specification, Pseudocode, Architecture, Refinement, Completion — structured development.',
-        tools: [],
-        commands: [],
-        agents: ['specification', 'pseudocode', 'architecture', 'refinement'],
-        skills: ['sparc-methodology'],
-        whenToUse: 'When following structured SPARC development methodology for new features.',
-    },
     'config-system': {
         name: 'Configuration & System',
         description: 'Configuration management, provider setup, system diagnostics, shell completions.',
@@ -201,7 +192,7 @@ const TASK_ROUTES = [
     { pattern: /\b(release|deploy|publish|version|changelog)\b/i, areas: ['github-integration', 'session-workflow'], workflow: 'release' },
     { pattern: /\b(swarm|multi.agent|coordin|hive|consensus)\b/i, areas: ['swarm-orchestration', 'hive-mind'], workflow: 'swarm' },
     { pattern: /\b(learn|train|neural|pattern|sona|lora)\b/i, areas: ['intelligence-learning'], workflow: 'learning' },
-    { pattern: /\b(hook|pre.task|post.task|worker|daemon)\b/i, areas: ['hooks-automation', 'session-workflow'], workflow: 'automation' },
+    { pattern: /\b(hook|pre.task|post.task|worker)\b/i, areas: ['hooks-automation', 'session-workflow'], workflow: 'automation' },
     { pattern: /\b(config|setup|init|provider|doctor)\b/i, areas: ['config-system'], workflow: 'setup' },
 ];
 const WORKFLOW_TEMPLATES = {
@@ -266,7 +257,7 @@ const WORKFLOW_TEMPLATES = {
         topology: 'hierarchical',
     },
     setup: {
-        steps: ['Run doctor diagnostics', 'Configure providers', 'Initialize memory', 'Start daemon'],
+        steps: ['Run doctor diagnostics', 'Configure providers', 'Initialize memory'],
         agents: [],
         topology: 'hierarchical',
     },
@@ -570,7 +561,6 @@ const guidanceQuickRef = {
                 commands: [
                     { cmd: 'npx monomind@latest init --wizard', desc: 'Initialize project with interactive setup' },
                     { cmd: 'npx monomind@latest doctor --fix', desc: 'Run diagnostics and auto-fix issues' },
-                    { cmd: 'npx monomind@latest daemon start', desc: 'Start background workers' },
                     { cmd: 'npx monomind@latest status', desc: 'Check system status' },
                 ],
             },

package/packages/@monomind/cli/dist/src/mcp-tools/hive-mind-tools.d.ts

@@ -1,7 +1,14 @@
 /**
  * Hive-Mind MCP Tools for CLI
  *
- * Tool definitions for collective intelligence and swarm coordination.
+ * Tool definitions for multi-agent coordination and voting.
+ *
+ * Honest scope note: the "consensus strategies" here are vote-count thresholds
+ * applied to a single in-process tally — NOT distributed consensus protocols.
+ * There is no log replication, leader election, network partitioning, or
+ * adversarial fault model. 'bft' = require 2f+1 votes, 'raft' = require
+ * majority, 'quorum' = configurable preset (majority/supermajority/unanimous).
+ * The names are kept for CLI/API compatibility.
  */
 import { type MCPTool } from './types.js';
 export declare const hiveMindTools: MCPTool[];

package/packages/@monomind/cli/dist/src/mcp-tools/hive-mind-tools.js

@@ -1,12 +1,20 @@
 /**
  * Hive-Mind MCP Tools for CLI
  *
- * Tool definitions for collective intelligence and swarm coordination.
+ * Tool definitions for multi-agent coordination and voting.
+ *
+ * Honest scope note: the "consensus strategies" here are vote-count thresholds
+ * applied to a single in-process tally — NOT distributed consensus protocols.
+ * There is no log replication, leader election, network partitioning, or
+ * adversarial fault model. 'bft' = require 2f+1 votes, 'raft' = require
+ * majority, 'quorum' = configurable preset (majority/supermajority/unanimous).
+ * The names are kept for CLI/API compatibility.
  */
 import { existsSync, readFileSync, statSync, writeFileSync, renameSync, mkdirSync } from 'node:fs';
+import { randomBytes } from 'node:crypto';
 import { join } from 'node:path';
 import { getProjectCwd } from './types.js';
-import { weightedTally } from '../consensus/vote-signer.js';
+import { weightedTally } from '../consensus/tally.js';
 // Storage paths
 const STORAGE_DIR = '.monomind';
 const HIVE_DIR = 'hive-mind';
@@ -125,6 +133,48 @@ function saveHiveState(state) {
     writeFileSync(tmp, JSON.stringify(state, null, 2), 'utf-8');
     renameSync(tmp, dest);
 }
+const SESSION_SECRET_FILE = 'session-secret';
+/**
+ * Resolve the HMAC signing secret used for consensus vote/audit records.
+ *
+ * Previously this was read exclusively from MONOMIND_SESSION_SECRET, which
+ * nothing in `init`/`doctor`/docs ever sets — so by default every consensus
+ * decision silently produced zero audit records (writes were skipped, and
+ * hive-mind_audit_verify refused to run at all). To make the audit trail
+ * work out of the box, fall back to a per-project secret generated once and
+ * persisted alongside the hive state (0600-equivalent: kept out of state.json
+ * and never returned by any tool). MONOMIND_SESSION_SECRET still takes
+ * precedence for callers that want to manage/rotate the secret themselves.
+ */
+function getOrCreateSessionSecret() {
+    const envSecret = process.env.MONOMIND_SESSION_SECRET;
+    if (envSecret)
+        return envSecret;
+    const path = join(getHiveDir(), SESSION_SECRET_FILE);
+    try {
+        if (existsSync(path)) {
+            const existing = readFileSync(path, 'utf-8').trim();
+            if (existing)
+                return existing;
+        }
+    }
+    catch { /* fall through to regeneration */ }
+    try {
+        ensureHiveDir();
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const secret = randomBytes(32).toString('hex');
+        const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+        writeFileSync(tmp, secret, 'utf-8');
+        renameSync(tmp, path);
+        return secret;
+    }
+    catch {
+        // Filesystem unavailable — fall back to an ephemeral in-process secret.
+        // Audit records signed with this won't verify across process restarts,
+        // but propose/vote/resolve still function.
+        return randomBytes(32).toString('hex');
+    }
+}
 // Import agent store helpers for spawn functionality
 import { existsSync as agentStoreExists, readFileSync as readAgentStore, writeFileSync as writeAgentStore, mkdirSync as mkdirAgentStore } from 'node:fs';
 // Canonical agent store path matches agent-tools.ts: .monomind/agents/store.json
@@ -256,17 +306,33 @@ export const hiveMindTools = [
                 updatedAt: now,
             };
             saveHiveState(state);
+            // Validate consensus strategy: gossip and crdt are planned but not implemented
+            const SUPPORTED_CONSENSUS = ['byzantine', 'bft', 'raft', 'quorum'];
+            const PLANNED_CONSENSUS = ['gossip', 'crdt'];
+            const requestedConsensus = input.consensus || 'byzantine';
+            const consensusWarning = PLANNED_CONSENSUS.includes(requestedConsensus)
+                ? `Strategy "${requestedConsensus}" is planned but not yet implemented; defaulting to "byzantine".`
+                : undefined;
+            const effectiveConsensus = PLANNED_CONSENSUS.includes(requestedConsensus)
+                ? 'byzantine'
+                : (SUPPORTED_CONSENSUS.includes(requestedConsensus) ? requestedConsensus : 'byzantine');
+            // Persist the chosen strategy on the hive state so hive-mind_consensus
+            // propose/vote default to it instead of silently using 'raft'.
+            // 'byzantine' is the CLI-facing name; the internal ConsensusStrategy type uses 'bft'.
+            state.consensusStrategy = (effectiveConsensus === 'byzantine' ? 'bft' : effectiveConsensus);
+            saveHiveState(state);
             return {
                 success: true,
                 hiveId,
                 topology: state.topology,
-                consensus: input.consensus || 'byzantine',
+                consensus: effectiveConsensus,
                 queenId,
                 neuralLearning: 'unavailable',
                 status: 'initialized',
+                ...(consensusWarning ? { warning: consensusWarning } : {}),
                 config: {
                     topology: state.topology,
-                    consensus: input.consensus || 'byzantine',
+                    consensus: effectiveConsensus,
                     maxAgents: input.maxAgents || 15,
                     persist: input.persist !== false,
                     memoryBackend: input.memoryBackend || 'hybrid',
@@ -470,7 +536,20 @@ export const hiveMindTools = [
         handler: async (input) => {
             const state = loadHiveState();
             const action = input.action;
-            const strategy = input.strategy || 'raft';
+            // Default to the strategy chosen at hive-mind_init (state.consensusStrategy);
+            // fall back to 'raft' only when the hive hasn't been initialized with one.
+            const rawStrategy = input.strategy || state.consensusStrategy || 'raft';
+            // Gossip and CRDT are planned but not yet implemented -- reject early
+            // with an honest message instead of silently falling through.
+            const UNIMPLEMENTED_STRATEGIES = ['gossip', 'crdt'];
+            if (UNIMPLEMENTED_STRATEGIES.includes(rawStrategy)) {
+                return {
+                    action,
+                    error: `Strategy "${rawStrategy}" is planned but not yet implemented. Available strategies: bft, raft, quorum.`,
+                    availableStrategies: ['bft', 'raft', 'quorum'],
+                };
+            }
+            const strategy = rawStrategy;
             const totalNodes = state.workers.length;
             if (action === 'propose') {
                 const proposalId = `proposal-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
@@ -694,42 +773,39 @@ export const hiveMindTools = [
                         });
                     }
                     catch { /* LanceDB not available — JSON store is primary */ }
-                    // Persist consensus audit record
-                    const sessionSecret = process.env.MONOMIND_SESSION_SECRET;
-                    if (!sessionSecret) {
-                        process.stderr.write('[hive-consensus] Audit write skipped: MONOMIND_SESSION_SECRET not set\n');
+                    // Persist consensus audit record — uses MONOMIND_SESSION_SECRET when
+                    // set, otherwise a per-project generated-and-persisted secret so the
+                    // audit trail is populated by default (see getOrCreateSessionSecret).
+                    const sessionSecret = getOrCreateSessionSecret();
+                    try {
+                        const { AuditWriter } = await import('../consensus/audit-writer.js');
+                        const auditDir = join(getProjectCwd(), STORAGE_DIR, 'consensus');
+                        const writer = new AuditWriter(auditDir);
+                        const now = new Date().toISOString();
+                        const voteEntries = Object.entries(proposal.votes).map(([agentId, vote]) => ({
+                            agentId,
+                            agentSlug: agentId,
+                            vote,
+                            votedAt: now,
+                        }));
+                        writer.record({
+                            decisionId: proposal.proposalId,
+                            swarmId: `hive-${state.createdAt ? new Date(state.createdAt).getTime() : Date.now()}`,
+                            protocol: (proposalStrategy === 'bft' ? 'byzantine' : proposalStrategy === 'raft' ? 'raft' : 'quorum'),
+                            topic: proposal.type,
+                            decision: resolution,
+                            votes: voteEntries,
+                            quorumRequired: required,
+                            quorumThreshold: required / Math.max(totalNodes, 1),
+                            round: (proposal.divergenceRoundsSeen ?? 0) + 1,
+                            startedAt: proposal.proposedAt,
+                            completedAt: now,
+                            sessionSecret,
+                        });
                     }
-                    else {
-                        try {
-                            const { AuditWriter } = await import('../consensus/audit-writer.js');
-                            const auditDir = join(getProjectCwd(), STORAGE_DIR, 'consensus');
-                            const writer = new AuditWriter(auditDir);
-                            const now = new Date().toISOString();
-                            const voteEntries = Object.entries(proposal.votes).map(([agentId, vote]) => ({
-                                agentId,
-                                agentSlug: agentId,
-                                vote,
-                                votedAt: now,
-                            }));
-                            writer.record({
-                                decisionId: proposal.proposalId,
-                                swarmId: `hive-${state.createdAt ? new Date(state.createdAt).getTime() : Date.now()}`,
-                                protocol: (proposalStrategy === 'bft' ? 'byzantine' : proposalStrategy === 'raft' ? 'raft' : 'quorum'),
-                                topic: proposal.type,
-                                decision: resolution,
-                                votes: voteEntries,
-                                quorumRequired: required,
-                                quorumThreshold: required / Math.max(totalNodes, 1),
-                                round: (proposal.divergenceRoundsSeen ?? 0) + 1,
-                                startedAt: proposal.proposedAt,
-                                completedAt: now,
-                                sessionSecret,
-                            });
-                        }
-                        catch (e) {
-                            if (process.env.MONOMIND_LOG_LEVEL === 'debug') {
-                                process.stderr.write(`[hive-consensus] Audit write failed: ${e.message}\n`);
-                            }
+                    catch (e) {
+                        if (process.env.MONOMIND_LOG_LEVEL === 'debug') {
+                            process.stderr.write(`[hive-consensus] Audit write failed: ${e.message}\n`);
                         }
                     }
                 }
@@ -1025,5 +1101,87 @@ export const hiveMindTools = [
             return { action, error: 'Unknown action' };
         },
     },
+    {
+        name: 'hive-mind_audit_list',
+        description: 'List tamper-evident consensus audit records (HMAC-signed JSONL trail)',
+        category: 'hive-mind',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                swarmId: { type: 'string', description: 'Filter by swarm ID (optional)' },
+                limit: { type: 'number', description: 'Max records to return (default: 50, max: 500)' },
+            },
+        },
+        handler: async (input) => {
+            try {
+                const { AuditWriter } = await import('../consensus/audit-writer.js');
+                const auditDir = join(getProjectCwd(), STORAGE_DIR, 'consensus');
+                const writer = new AuditWriter(auditDir);
+                const limit = Math.min(Math.max(1, input.limit || 50), 500);
+                const swarmId = input.swarmId;
+                const records = writer.listDecisions(swarmId, limit);
+                return {
+                    success: true,
+                    count: records.length,
+                    records: records.map(r => ({
+                        decisionId: r.decisionId,
+                        swarmId: r.swarmId,
+                        protocol: r.protocol,
+                        topic: r.topic,
+                        decision: r.decision,
+                        voteCount: r.votes.length,
+                        quorumAchieved: r.quorumAchieved,
+                        round: r.round,
+                        durationMs: r.durationMs,
+                        completedAt: r.completedAt,
+                        signed: !!r.recordSignature,
+                    })),
+                };
+            }
+            catch (e) {
+                return { success: false, error: `Audit trail unavailable: ${e.message}` };
+            }
+        },
+    },
+    {
+        name: 'hive-mind_audit_verify',
+        description: 'Verify tamper-evidence of a consensus decision (checks HMAC signatures on all votes and the record itself)',
+        category: 'hive-mind',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                decisionId: { type: 'string', description: 'Decision/proposal ID to verify' },
+            },
+            required: ['decisionId'],
+        },
+        handler: async (input) => {
+            // Uses MONOMIND_SESSION_SECRET when set, otherwise the same
+            // per-project generated-and-persisted secret used to sign records
+            // in hive-mind_consensus (see getOrCreateSessionSecret).
+            const sessionSecret = getOrCreateSessionSecret();
+            const decisionId = input.decisionId;
+            if (typeof decisionId !== 'string' || decisionId.length === 0 || decisionId.length > 256) {
+                return { success: false, error: 'Invalid decisionId' };
+            }
+            try {
+                const { AuditWriter } = await import('../consensus/audit-writer.js');
+                const auditDir = join(getProjectCwd(), STORAGE_DIR, 'consensus');
+                const writer = new AuditWriter(auditDir);
+                const result = writer.verifyDecision(decisionId, sessionSecret);
+                return {
+                    success: true,
+                    decisionId,
+                    valid: result.valid,
+                    invalidVotes: result.invalidVotes,
+                    message: result.valid
+                        ? 'All vote signatures and record signature verified — no tampering detected.'
+                        : `Verification failed: ${result.invalidVotes.length} invalid vote(s) or record signature mismatch.`,
+                };
+            }
+            catch (e) {
+                return { success: false, error: `Audit verification failed: ${e.message}` };
+            }
+        },
+    },
 ];
 //# sourceMappingURL=hive-mind-tools.js.map