v3.0.0-beta.2 — CI Green, Shared Memory, Full Test Coverage

What's New Since beta.1

CI Pipeline — All Green ✓

• 6/6 jobs passing: typecheck-lint, integration-tests, cache-tests × Node 20 + 22
• Fixed test hangs from unclosed Redis/DB connections
• Fixed 10+ SQL bugs (recursive CTE, parameter types, dangling params)
• Fixed race conditions in async fire-and-forget operations
• Added 10-minute job timeouts as safety net

Cross-Agent Shared Memory (Phase 3)

• Shared pools with team/global hierarchy
• Publish memories to pools with provenance chains
• Hearsay discounting: confidence × (0.8^hop_count) × agent_reputation
• Per-domain agent reputation system (corroboration/contradiction tracking)
• Pool sleep cycles (deduplication, conflict resolution, corroboration promotion)

Security & Integrity

• Content classification and pre-LLM sanitization
• Temporal audit chain with HMAC cryptographic integrity
• Audit chain wired into all 14 mutation points
• 10 security rounds completed (MEDIUM+ clean)

Active Knowledge Management

• Staleness detection with auto-confidence decay
• Prioritized experience replay (surprise scoring)
• Multi-factor conflict resolution
• Temporal event chains
• Knowledge gap detection
• Schema pattern crystallization

Project Cleanup

• 30 GitHub issues closed as completed
• 21 open issues remain as future roadmap
• Dead code removed, attack surface reduced

Getting Started

# Docker standalone (no external deps)
docker run -p 3333:3333 salishforge/memforge:standalone

# Or with Docker Compose
git clone https://github.com/salishforge/memforge.git
cd memforge && cp .env.docker .env
docker compose up -d

See README for TypeScript/Python SDK, MCP integration, and REST API docs.

Contributing

Issues labeled good first issue are great starting points. See the open issues for the full roadmap.

v2.1.0-alpha — Architecture Complete

First public release of MemForge

Neuroscience-inspired memory system for AI agents with sleep cycles that actively rewrite and strengthen stored knowledge.

What's built

• Tiered memory (hot → warm → cold) with PostgreSQL, pgvector, and Redis
• Hybrid search — keyword FTS, semantic vectors, reciprocal rank fusion
• Knowledge graph — entities and relationships via recursive CTEs (no Neo4j)
• Sleep cycles — 5-phase background processor: scoring → triage → LLM revision → graph maintenance → reflection
• Memory revision engine — LLM rewrites low-confidence memories (augment, correct, merge, compress)
• Reflection & meta-reflection — LLM synthesizes insights, detects contradictions, extracts procedures
• Outcome feedback — track whether retrieved memories led to good outcomes
• Active recall — proactively surface memories before agent actions
• MCP server — 17 tools for Claude Code, Cursor, and MCP-compatible AI tools
• TypeScript SDK — with ResilientMemForgeClient for graceful degradation
• LLM tool definitions — OpenAI function calling and Anthropic tool_use formats

Status: Alpha

Architecture is complete. Code compiles and passes type-checking. Not yet validated against a live database. We're releasing early because the design is novel and we want feedback.

Get Started

See INTEGRATION.md for how to wire MemForge into your agent (any framework, any language).

See ROADMAP.md for the long-term vision.

MemForge v0.1.0-alpha

🧠 Salish Forge MemForge Alpha Release

Overview
Multi-tenant memory consolidation service for AI agents. Provides persistent, semantically searchable memory with automatic tiering (hot/warm/cold) and consolidation.

Features
✅ Multi-agent memory isolation (per-agent_id row-level security)
✅ Hot/Warm/Cold tier consolidation (auto, time-based, manual modes)
✅ PostgreSQL + pgvector full-text semantic search
✅ Parameterized SQL (no injection vulnerabilities)
✅ REST API (/memory/:agentId endpoints)
✅ Consolidation audit logging
✅ TypeScript implementation with full type safety

Performance

• Response time: 10ms avg (target: 500ms) ✅
• Consolidation: 500 items/batch, configurable
• Memory: ~18MB stable, no leaks detected
• Zero errors under load

Database Schema

• hot_tier: Recent memories, fast access
• warm_tier: Consolidated memories, FTS indexed
• cold_tier: Archived memories (>90 days), compressed
• consolidation_audit: Full audit trail of all operations

Deployment

# Docker
docker run -e DATABASE_URL=postgres://... -p 3333:3000 salishforge/memforge:v0.1.0-alpha

# Systemd
systemctl start memforge

Security
✅ Parameterized SQL queries (prevents injection)
✅ Multi-tenant isolation (verified)
✅ Database credentials via environment variables
✅ Framework headers disabled
✅ Rate limiting framework in place

Known Issues

• Source code contains hardcoded credentials (in src/); will be refactored in v0.2.0
  • Mitigation: .env file required (no fallback), credentials to be rotated before production

Testing

• Load tests: 50 concurrent requests, 0 errors ✅
• Integration tests: Service registration working ✅
• Memory isolation: Verified (Agent A cannot read Agent B memory) ✅

Documentation

• API: See MEMFORGE_EXTRACTION_SPEC.md
• Schema: See schema/schema.sql
• Deployment: See production deployment guide

Contributors
Flint (CTO) — Implementation, security audit, testing

Next Steps

• v0.1.1: Rotate PostgreSQL credentials
• v0.2.0: Remove hardcoded credentials from source
• v0.2.0: Add Redis caching layer for hot_tier
• v0.3.0: Implement distributed consolidation