mark-improving-agent 2.2.4 → 2.2.5

package/VERSION

@@ -1 +1 @@
-2.2.4
+2.2.5

package/dist/core/collaboration/index.js

@@ -2,3 +2,4 @@ export * from './multi-agent.js';
 export * from './agentic-loop.js';
 export * from './multi-agent-system.js';
 export { createMCPProtocol } from './mcp-protocol.js';
+export { createPeerReviewSystem } from './peer-review.js';

package/dist/core/collaboration/peer-review.js

@@ -0,0 +1,265 @@
+/**
+ * Multi-Agent Peer Review System
+ *
+ * Enables cross-model peer review of agent decisions and outputs.
+ * Based on agentic-fleet-hub's peer review architecture.
+ *
+ * Key features:
+ * - Multiple agents review each other's work
+ * - Consensus-based approval
+ * - Dissent tracking for quality improvement
+ * - Reputation-weighted voting
+ *
+ * @module core/collaboration
+ * @fileoverview Cross-model peer review for agent outputs
+ */
+import { randomUUID } from 'crypto';
+import { createLogger } from '../../utils/logger.js';
+const logger = createLogger('PeerReview');
+/**
+ * Default reviewers
+ */
+const DEFAULT_REVIEWERS = [
+    {
+        id: 'reviewer-logic',
+        name: 'Logic Reviewer',
+        model: 'claude-opus',
+        specialties: ['reasoning', 'logic', 'consistency'],
+        reputation: 0.95,
+        reviewsCompleted: 0,
+        approvalRate: 0,
+    },
+    {
+        id: 'reviewer-safety',
+        name: 'Safety Reviewer',
+        model: 'claude-opus',
+        specialties: ['safety', 'ethics', 'harm prevention'],
+        reputation: 0.98,
+        reviewsCompleted: 0,
+        approvalRate: 0,
+    },
+    {
+        id: 'reviewer-quality',
+        name: 'Quality Reviewer',
+        model: 'claude-sonnet',
+        specialties: ['code quality', 'documentation', 'best practices'],
+        reputation: 0.92,
+        reviewsCompleted: 0,
+        approvalRate: 0,
+    },
+    {
+        id: 'reviewer-creativity',
+        name: 'Creativity Reviewer',
+        model: 'claude-haiku',
+        specialties: ['innovation', 'alternatives', 'creative solutions'],
+        reputation: 0.88,
+        reviewsCompleted: 0,
+        approvalRate: 0,
+    },
+];
+export function createPeerReviewSystem(options) {
+    const consensusThreshold = options?.consensusThreshold ?? 0.7;
+    const requiredReviewers = options?.requiredReviewers ?? 3;
+    const enableArbitration = options?.enableArbitration ?? true;
+    // State
+    const items = new Map();
+    const reviewers = new Map(DEFAULT_REVIEWERS.map(r => [r.id, r]));
+    const sessions = new Map();
+    const reviewHistory = [];
+    // Stats
+    let totalReviewTime = 0;
+    let consensusCount = 0;
+    let revisionCount = 0;
+    function submitItem(submitterId, content, type, context, options) {
+        const item = {
+            id: randomUUID(),
+            submitterId,
+            content,
+            type,
+            context: context ?? {},
+            status: 'pending',
+            votes: [],
+            createdAt: Date.now(),
+            consensusThreshold: options?.consensusThreshold ?? consensusThreshold,
+            requiredReviewers: options?.requiredReviewers ?? requiredReviewers,
+        };
+        items.set(item.id, item);
+        logger.info(`Review item submitted: ${item.id} by ${submitterId}`);
+        // Auto-assign reviewers
+        assignReviewers(item.id);
+        return item;
+    }
+    function registerReviewer(reviewer) {
+        reviewers.set(reviewer.id, {
+            ...reviewer,
+            reviewsCompleted: 0,
+            approvalRate: 0,
+        });
+        logger.info(`Reviewer registered: ${reviewer.name}`);
+    }
+    function getReviewersForType(contentType) {
+        const relevantReviewers = Array.from(reviewers.values()).filter(r => r.specialties.some(s => contentType === 'code' ? s.includes('code') :
+            contentType === 'decision' ? s.includes('reasoning') || s.includes('logic') :
+                contentType === 'response' ? s.includes('ethics') || s.includes('safety') :
+                    true));
+        // Return up to 4 reviewers
+        return relevantReviewers.slice(0, 4);
+    }
+    function assignReviewers(itemId) {
+        const item = items.get(itemId);
+        if (!item || item.status !== 'pending')
+            return null;
+        const availableReviewers = getReviewersForType(item.type)
+            .filter(r => r.id !== item.submitterId)
+            .slice(0, item.requiredReviewers);
+        if (availableReviewers.length < 2) {
+            // Use default reviewers if no specialty match
+            const defaults = Array.from(reviewers.values())
+                .filter(r => r.id !== item.submitterId)
+                .slice(0, item.requiredReviewers);
+            availableReviewers.push(...defaults);
+        }
+        const session = {
+            itemId,
+            phase: 'review',
+            assignedReviewers: availableReviewers.map(r => r.id),
+            completedReviews: 0,
+            consensusReached: false,
+        };
+        sessions.set(itemId, session);
+        item.status = 'in_review';
+        logger.info(`Assigned ${availableReviewers.length} reviewers to ${itemId}`);
+        return item;
+    }
+    function submitVote(itemId, reviewerId, decision, feedback, confidence) {
+        const item = items.get(itemId);
+        const session = sessions.get(itemId);
+        const reviewer = reviewers.get(reviewerId);
+        if (!item || !session || !reviewer) {
+            logger.warn(`Invalid vote submission: item=${itemId}, reviewer=${reviewerId}`);
+            return null;
+        }
+        // Check if reviewer is assigned
+        if (!session.assignedReviewers.includes(reviewerId)) {
+            logger.warn(`Reviewer ${reviewerId} not assigned to ${itemId}`);
+            return null;
+        }
+        // Check if reviewer already voted
+        if (item.votes.some(v => v.reviewerId === reviewerId)) {
+            logger.warn(`Reviewer ${reviewerId} already voted on ${itemId}`);
+            return null;
+        }
+        const vote = {
+            reviewerId,
+            role: session.completedReviews === 0 ? 'primary' : 'secondary',
+            decision,
+            confidence: Math.max(0, Math.min(1, confidence)),
+            feedback,
+            timestamp: Date.now(),
+        };
+        item.votes.push(vote);
+        session.completedReviews++;
+        reviewHistory.push(vote);
+        // Update reviewer stats
+        reviewer.reviewsCompleted++;
+        logger.info(`Vote submitted: ${reviewerId} -> ${decision} on ${itemId}`);
+        // Check consensus
+        const consensus = checkConsensus(itemId);
+        if (consensus.reached && consensus.decision) {
+            item.status = consensus.decision;
+            item.completedAt = Date.now();
+            session.consensusReached = true;
+            session.decision = consensus.decision === 'approved' ? 'approved' :
+                consensus.decision === 'rejected' ? 'rejected' : 'revision_requested';
+            if (consensus.decision === 'revision_requested') {
+                revisionCount++;
+            }
+            consensusCount++;
+        }
+        return vote;
+    }
+    function checkConsensus(itemId) {
+        const item = items.get(itemId);
+        if (!item)
+            return { reached: false };
+        const requiredApprovals = Math.ceil(item.requiredReviewers * item.consensusThreshold);
+        const votes = item.votes;
+        // Need minimum votes
+        if (votes.length < item.requiredReviewers) {
+            return { reached: false };
+        }
+        // Count decisions
+        const approvals = votes.filter(v => v.decision === 'approve').length;
+        const rejections = votes.filter(v => v.decision === 'reject').length;
+        const revisions = votes.filter(v => v.decision === 'revision').length;
+        // Reputation-weighted voting
+        let weightedApprovals = 0;
+        let totalWeight = 0;
+        for (const vote of votes) {
+            const reviewer = reviewers.get(vote.reviewerId);
+            if (reviewer) {
+                const weight = reviewer.reputation * vote.confidence;
+                totalWeight += weight;
+                if (vote.decision === 'approve') {
+                    weightedApprovals += weight;
+                }
+            }
+        }
+        const weightedApprovalRate = totalWeight > 0 ? weightedApprovals / totalWeight : 0;
+        if (weightedApprovalRate >= item.consensusThreshold) {
+            return { reached: true, decision: 'approved' };
+        }
+        if (rejections > item.requiredReviewers / 2) {
+            // Check for revision option before outright rejection
+            if (enableArbitration && revisions > 0) {
+                return { reached: true, decision: 'revision_requested' };
+            }
+            return { reached: true, decision: 'rejected' };
+        }
+        // No consensus yet
+        return { reached: false };
+    }
+    function getItemStatus(itemId) {
+        return items.get(itemId);
+    }
+    function getPendingReviews(reviewerId) {
+        return Array.from(items.values()).filter(item => {
+            const session = sessions.get(item.id);
+            return (item.status === 'in_review' &&
+                session?.assignedReviewers.includes(reviewerId) &&
+                !item.votes.some(v => v.reviewerId === reviewerId));
+        });
+    }
+    function getStats() {
+        const allItems = Array.from(items.values());
+        const completedItems = allItems.filter(i => i.completedAt);
+        const avgReviewTime = completedItems.length > 0
+            ? totalReviewTime / completedItems.length
+            : 0;
+        return {
+            itemsReviewed: completedItems.length,
+            approvalRate: completedItems.length > 0
+                ? completedItems.filter(i => i.status === 'approved').length / completedItems.length
+                : 0,
+            avgReviewTime,
+            consensusRate: completedItems.length > 0
+                ? consensusCount / completedItems.length
+                : 0,
+            revisionRate: completedItems.length > 0
+                ? revisionCount / completedItems.length
+                : 0,
+            dissentCount: reviewHistory.filter(v => v.decision !== 'approve').length,
+        };
+    }
+    return {
+        submitItem,
+        registerReviewer,
+        getReviewersForType,
+        assignReviewers,
+        submitVote,
+        checkConsensus,
+        getItemStatus,
+        getPendingReviews,
+        getStats,
+    };
+}

package/dist/core/memory/hybrid-search.js

@@ -0,0 +1,177 @@
+/**
+ * Hybrid Memory Search
+ *
+ * Combines vector similarity search with BM25 keyword matching and knowledge graph traversal
+ * Based on Dakera AI's hybrid search architecture (87.8% LoCoMo accuracy)
+ *
+ * @module core/memory
+ * @fileoverview Hybrid search combining vector + BM25 + knowledge graph for superior recall
+ */
+import { createLogger } from '../../utils/logger.js';
+const logger = createLogger('HybridSearch');
+/**
+ * Default hybrid search configuration
+ */
+export const DEFAULT_HYBRID_CONFIG = {
+    vectorWeight: 0.5,
+    bm25Weight: 0.3,
+    kgWeight: 0.2,
+    bm25: { k1: 1.5, b: 0.75 },
+    minScore: 0.1,
+    maxResults: 20,
+};
+/**
+ * Tokenizer for BM25
+ */
+function tokenize(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^\w\s]/g, ' ')
+        .split(/\s+/)
+        .filter(token => token.length > 2);
+}
+/**
+ * Create a BM25 index from memory entries
+ */
+export function createBM25Index(entries) {
+    const index = {
+        docLengths: new Map(),
+        termDocFreq: new Map(),
+        avgDocLength: 0,
+        totalDocs: entries.length,
+        invertedIndex: new Map(),
+    };
+    let totalLength = 0;
+    for (const entry of entries) {
+        const tokens = tokenize(entry.content);
+        const docLength = tokens.length;
+        index.docLengths.set(entry.id, docLength);
+        totalLength += docLength;
+        // Count term frequencies
+        const termFreq = new Map();
+        for (const token of tokens) {
+            termFreq.set(token, (termFreq.get(token) ?? 0) + 1);
+            if (!index.invertedIndex.has(token)) {
+                index.invertedIndex.set(token, new Map());
+            }
+            const posting = index.invertedIndex.get(token);
+            posting.set(entry.id, termFreq.get(token));
+        }
+        // Update document frequency
+        for (const token of new Set(tokens)) {
+            index.termDocFreq.set(token, (index.termDocFreq.get(token) ?? 0) + 1);
+        }
+    }
+    index.avgDocLength = totalLength / Math.max(entries.length, 1);
+    return index;
+}
+/**
+ * Calculate BM25 score for a single document
+ */
+export function bm25Score(index, docId, queryTokens, config) {
+    const docLength = index.docLengths.get(docId) ?? 0;
+    let score = 0;
+    for (const token of queryTokens) {
+        const tf = index.invertedIndex.get(token)?.get(docId) ?? 0;
+        if (tf === 0)
+            continue;
+        const df = index.termDocFreq.get(token) ?? 0;
+        if (df === 0)
+            continue;
+        const idf = Math.log((index.totalDocs - df + 0.5) / (df + 0.5) + 1);
+        const tfComponent = (tf * (config.k1 + 1)) / (tf + config.k1 * (1 - config.b + config.b * (docLength / index.avgDocLength)));
+        score += idf * tfComponent;
+    }
+    return score;
+}
+/**
+ * Normalize BM25 scores to 0-1 range
+ */
+export function normalizeBM25Scores(scores) {
+    const maxScore = Math.max(...Array.from(scores.values()), 1);
+    const normalized = new Map();
+    for (const [docId, score] of scores) {
+        normalized.set(docId, score / maxScore);
+    }
+    return normalized;
+}
+/**
+ * Create a hybrid search engine
+ */
+export function createHybridSearchEngine(initialEntries = [], config = {}) {
+    const fullConfig = {
+        ...DEFAULT_HYBRID_CONFIG,
+        ...config,
+        bm25: { ...DEFAULT_HYBRID_CONFIG.bm25, ...config.bm25 },
+    };
+    let bm25Index = createBM25Index(initialEntries);
+    function rebuildIndex(entries) {
+        logger.info(`Rebuilding BM25 index with ${entries.length} documents`);
+        bm25Index = createBM25Index(entries);
+    }
+    function search(query, entries, options) {
+        const searchConfig = {
+            ...fullConfig,
+            ...options?.config,
+        };
+        // Tokenize query for BM25
+        const queryTokens = tokenize(query);
+        // Calculate BM25 scores for all entries
+        const bm25Scores = new Map();
+        for (const entry of entries) {
+            const score = bm25Score(bm25Index, entry.id, queryTokens, searchConfig.bm25);
+            if (score > 0) {
+                bm25Scores.set(entry.id, score);
+            }
+        }
+        const normalizedBM25 = normalizeBM25Scores(bm25Scores);
+        // Calculate KG scores based on connection count
+        const kgScores = new Map();
+        if (options?.kgConnections) {
+            const maxConnections = Math.max(...Array.from(options.kgConnections.values()).map(arr => arr.length), 1);
+            for (const entry of entries) {
+                const connections = options.kgConnections.get(entry.id)?.length ?? 0;
+                kgScores.set(entry.id, connections / maxConnections);
+            }
+        }
+        // Combine scores
+        const combinedResults = new Map();
+        for (const entry of entries) {
+            const vectorScore = options?.vectorScores?.get(entry.id) ?? 0;
+            const bm25Score = normalizedBM25.get(entry.id) ?? 0;
+            const kgScore = kgScores.get(entry.id) ?? 0;
+            // Weighted combination
+            const combinedScore = (vectorScore * searchConfig.vectorWeight) +
+                (bm25Score * searchConfig.bm25Weight) +
+                (kgScore * searchConfig.kgWeight);
+            if (combinedScore >= searchConfig.minScore) {
+                combinedResults.set(entry.id, {
+                    entry,
+                    score: combinedScore,
+                    combinedScore,
+                    vectorScore,
+                    bm25Score,
+                    kgScore,
+                    reason: 'semantic',
+                });
+            }
+        }
+        // Sort by combined score
+        const results = Array.from(combinedResults.values())
+            .sort((a, b) => b.combinedScore - a.combinedScore)
+            .slice(0, searchConfig.maxResults);
+        logger.debug(`Hybrid search for "${query}": ${results.length} results`);
+        return results;
+    }
+    function getStats() {
+        return {
+            indexedDocs: bm25Index.totalDocs,
+            avgDocLength: Math.round(bm25Index.avgDocLength),
+        };
+    }
+    return {
+        search,
+        rebuildIndex,
+        getStats,
+    };
+}

package/dist/core/memory/index.js

@@ -8,3 +8,4 @@ export * from './spaced-repetition.js';
 export * from './hopfield-network.js';
 export * from './adaptive-rag.js';
 export { createContextFragmentationEngine } from './context-fragmentation.js';
+export { createHybridSearchEngine, createBM25Index, bm25Score, normalizeBM25Scores, DEFAULT_HYBRID_CONFIG } from './hybrid-search.js';

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '2.2.4';
+export const VERSION = '2.2.5';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mark-improving-agent",
-  "version": "2.2.4",
+  "version": "2.2.5",
   "description": "Self-evolving AI agent with permanent memory, identity continuity, and self-evolution — for AI agents that need to remember, learn, and evolve across sessions",
   "type": "module",
   "main": "./dist/index.js",