JohnnyFiv3r/Core-Memory

This system is a comprehensive agent memory layer that captures, structures, and retrieves conversation history through a session-first architecture with append-only, agent-governed write integrity. It provides multi-modal retrieval capabilities, including semantic search, causal graph traversal, and hybrid lookup, while maintaining a structured claim layer for extracting and resolving facts. The system supports extensive integration with external agent frameworks and tools via MCP, HTTP, and specific adapters for LangChain, CrewAI, and PydanticAI, alongside robust benchmarking and observability tooling for evaluating memory quality.

Users can now connect Core Memory to CrewAI agents via three new integration classes: CoreMemoryShortTerm, CoreMemoryLongTerm, and CoreMemoryEntity. These adapters map Core Memory's bead lifecycle (open/candidate, promoted/archived, and entity-tagged) to CrewAI's standard memory interfaces, allowing CrewAI crews to read and write persistent context, lessons, and entity data through Core Memory's canonical write path.

_core\memory/integrations/crewai · high confidence

Introduces a new benchmark adapter for the LoCoMo long-conversation memory dataset, enabling evaluation of Core Memory's recall quality against a standardized corpus. The implementation includes a CLI entry point (\python -m benchmarks.locomo\) to load the external \locomo10.json\ corpus, ingest conversation turns into the memory system, and run retrieval/scoring cycles. It enforces strict isolation by evaluating each conversation in a temporary directory and prevents data contamination by keeping gold answers and evidence IDs in memory rather than writing them to the benchmark root. The adapter scores evidence recall in \dia\_id\ space to handle non-deterministic bead IDs and applies category-aware answer scoring (token F1 and multihop F1), while automatically excluding Category 5 (adversarial) questions which have known issues in the public corpus.

benchmarks/locomo · high confidence

Core Memory now supports delegating semantic task execution to an external HTTP endpoint via the new \RemoteSemanticTaskRuntime\. This adapter sends task requests to a configurable URL (set via \CORE\_MEMORY\_SEMANTIC\_TASK\_RUNTIME\_URL\) with a bearer token, allowing the LLM judgment logic to be handled by an external agent conductor while keeping the engine's local semantics intact. It includes configurable timeouts, strict mode, and a fallback mechanism to a local runtime if the remote service is unavailable or misconfigured.

_core\memory/integrations/remote · high confidence

The Core Memory retrieval pipeline now supports user-configurable domain tags and query expansions, allowing users to override or extend shipped defaults via YAML files in their config directory to improve retrieval alignment. Additionally, runtime behavior is now controlled through a centralized feature flags module that reads environment variables (e.g., CORE\_MEMORY\_AGENT\_AUTHORED\_REQUIRED, CORE\_MEMORY\_CLAIM\_LAYER) to enable or disable capabilities like agent-authored memory enforcement, claim extraction, and transcript hydration.

_core\memory/config · high confidence

A new HTTP-compatible ingress surface has been added to the core memory integrations, allowing applications to access the SpringAI application via a standard HTTP interface. This module provides a \get\_app()\ function that attempts to load the FastAPI-based server; if FastAPI is not available, it gracefully falls back to a minimal stub application, ensuring the integration layer remains robust even in environments with missing dependencies.

_core\memory/integrations/http · high confidence

The new Core Memory Bridge plugin connects OpenClaw lifecycle hooks to Core Memory's canonical write, read, and flush surfaces. It registers memory prompt supplements (skill instructions and agent-authoring specs), validates Core Memory Python modules at startup, and executes bridge subprocesses with configurable timeouts and fallback delays. Users can configure local vs. hosted Core Memory endpoints, enable or disable specific features like memory search and compaction flushing, and control fallback behavior for message turns.

plugins/openclaw-core-memory-bridge · high confidence

The \core\_memory\ package is now the authoritative, root-level module for agent memory, replacing the previous \tools/mem-beads\ location. This release (v1.1.1) establishes a session-first architecture where finalized turns are the canonical write ingress, exposing a unified public API for capture, recall, and maintenance. Key capabilities include multi-speaker transcript ingestion with role normalization, a GitHub connector for ingesting pull requests and issues as structured evidence, and provider-neutral LLM integration that supports GPT-5 parameters (e.g., \max\_completion\_tokens\). The module also introduces a 'SOUL' surface for agent self-modeling and goal management, association coverage for linking memory beads, and strict validation for archive identifiers to prevent path traversal.

_core\memory · high confidence

The Dreamer module is now a fully realized runtime package that performs structural recombination analysis to discover novel connections between memory beads. It introduces several new hypothesis types for user review: latent goal candidates based on recurring behavior themes, goal decay warnings for dormant objectives, identity and value research findings comparing observed behavior against endorsed self-concepts, and narrative candidates derived from worldline convergence. The engine also provides a continuity-geometry projection manifest for visualization, integrates retrieval feedback into candidate confidence, and includes a dedicated evaluation framework for tracking precision and actionability of these suggestions.

_core\memory/runtime/dreamer · high confidence

This change adds a new MCP (Model Context Protocol) integration layer under \core\_memory/integrations/mcp\, exposing Core Memory capabilities to external clients via a streamable-HTTP server. It provides a suite of typed read tools (such as \query\_current\_state\, \query\_temporal\_window\, \query\_causal\_chain\, and \query\_contradictions\) and write tools (including \write\_turn\_finalized\, \apply\_reviewed\_proposal\, and \submit\_entity\_merge\_proposal\), along with a governed \maintain\ facade for administrative actions. The integration includes a CLI for client configuration and health checks, a canonical agent guide for instruction injection, and security hardening for hosted modes that locks the memory root to prevent arbitrary filesystem access.

_core\memory/integrations/mcp · high confidence

This change adds the SOUL module, a new agent-authored self-model layer that maintains a revision-backed, human-governed theory of self across files like SOUL.md, GOALS.md, IDENTITY.md, and TENSIONS.md. It provides a goal lifecycle (propose, approve, reject, complete, abandon, decay) backed by Goal Beads and a state machine, and a Dreamer bridge that routes candidate findings into proposed SOUL revisions requiring human approval before application. Structural integrity checks auto-repair only safe, machine-authored issues (like empty entries) while reporting others for review, and session-start injection automatically prepends the current self-model to working memory. Read-only continuity summaries and signal detectors (assembly depth, identity/value signals, tension/goal conflicts) provide metrics without mutating state.

_core\memory/soul · high confidence

The system now automatically generates and evaluates potential links between memory items (associations) and tracks progress toward defined goals. This change introduces a runtime orchestration layer that proposes association candidates, routes them through an agent-based judge for quality control (accept, reject, modify, etc.), and persists the decisions. It also adds specific workflows for monitoring goal progress, allowing the system to identify evidence that supports active goals and backfill progress records. Users will see more curated and verified connections in their memory graph, along with structured tracking of how evidence contributes to high-level objectives.

_core\memory/runtime/associations · high confidence

Users now have access to a standardized set of memory retrieval tools located in the \core\_memory/retrieval/tools\ package. This includes a unified \search\ function that accepts both \request\ and legacy \form\_submission\ parameters for backward compatibility, a \trace\ function for exploring memory chains with configurable depth, a \plan\ function for roadmap-based query planning, and an \execute\ function that respects environment variables to enable or disable execution (including specific controls for causal execution). Additionally, a new \memory\_reason\ module provides freeform reasoning capabilities for intent-based queries (such as 'why', 'when', or 'what changed'), and a \memory\_search\ module offers a typed search endpoint with deterministic snapping.

_core\memory/retrieval/tools · high confidence

The core memory persistence layer now supports a pluggable graph backend architecture, allowing users to choose how memory relationships are stored and traversed. By default, the system uses an embedded Kuzu graph database for local, zero-ops causal traversal. Users can switch to a remote Neo4j instance or the Graphiti temporal knowledge graph backend by setting the CORE\_MEMORY\_GRAPH\_BACKEND environment variable. The system includes a factory mechanism that safely falls back to a null backend if the chosen provider fails to initialize, ensuring system stability. This change enables advanced relationship tracking and search capabilities while maintaining backward compatibility through the null fallback.

_core\memory/persistence/graph · high confidence

The ingest module now provides dedicated, typed pathways for processing external data sources and managing versioned document chunks. Users can ingest structured observations, state assertions, operational events, and document references through a new external evidence handler that normalizes source envelopes and resolves bead types based on data flags. Additionally, a new chunk turns system allows for the ingestion of versioned document/media segments with strict identity hashing and immutability checks, while a separate data insight path converts PipeHouse rows into turn envelopes. This change establishes a robust, provenance-aware foundation for importing heterogeneous external data into the core memory.

_core\memory/runtime/ingest · high confidence

The system now includes a dedicated claim management package that extracts structured facts (such as preferences, identity, and policies) from conversation turns, resolves conflicts between contradictory claims through a review process, and determines how to answer user queries based on the current state and confidence of those claims.

_core\memory/claim · high confidence

This change establishes the \core\_memory/persistence\ module, providing the foundational storage and management capabilities for the memory system. It introduces transparent encryption at rest for session and index files using Fernet (AES-128-CBC), configurable via environment variables. The module adds a durable event logging system for audit trails and index rebuilding, alongside a schema audit surface to track canonical and legacy event formats. It also implements a comprehensive goal lifecycle v2 (candidate, endorsed, active, completed, abandoned, decaying), entity merge flows with heuristic similarity detection, and bead hygiene contracts for classifying write richness and retrieval eligibility. Additional features include an archive index for O(1) snapshot retrieval, calibration curves for confidence scoring, and failure pattern detection for repeated hypothesis tracking.

_core\memory/persistence · high confidence

The \core\_memory/runtime/turn\ module now implements a governed, append-only semantic reauthoring system that allows the runtime to repair and re-author memory turns while maintaining strict mechanical provenance. This change introduces a durable semantic-write state tracker to monitor the lifecycle of turns (pending, committed, failed, or repair\_required) and enforces hard agent-authored semantic writes through a typed \AgentAuthoredUpdatesV1\ contract. Users benefit from improved reliability and auditability, as the system now validates authority, attaches source provenance, and schedules post-commit association coverage for maintenance operations without fabricating context, ensuring that semantic interpretations remain traceable and repairable.

_core\memory/runtime/turn · high confidence

The \core\_memory/retrieval\ package has been restructured into a modular system that significantly expands how users retrieve information. This change introduces a causal recall pipeline that detects intent keywords (e.g., 'cause', 'why') to traverse association graphs for multi-hop evidence, and a hybrid lookup engine that leverages Qdrant for combined semantic and lexical search while falling back to FAISS. It also adds a fan-out mechanism that parallelizes queries to external stores like PipeHouse, merging results with core memory using configurable weights and unifying IDs. Additionally, the system now supports chunk-level evidence resolution, context-aware retrieval with strict/fallback matching, and deterministic incident/topic anchoring to improve result relevance.

_core\memory/retrieval · high confidence

The repository now includes a structured benchmarking package (\benchmarks/\) designed to evaluate long-conversation memory quality. This new tooling provides several specialized harnesses: a LOCOMO-shaped local harness for semantic QA, a causal-chain reconstruction harness for measuring edge precision and grounding, a causal-continuity suite for assessing temporal state selection and thread fidelity, and a LongMemEval adapter for smoke-testing user-supplied corpora against a shared contract. The package is initialized with a README detailing quick-start commands for running local subsets, emitting reports, and validating adapters without vendoring external datasets.

benchmarks · high confidence

Adds a new LangChain integration module that bridges Core Memory's causal memory system to LangChain applications. This includes a \CoreMemory\ class implementing the \BaseMemory\ protocol to inject rolling-window continuity context (including optional self-model data) into conversation chains and persist turn data back to Core Memory, as well as a \CoreMemoryRetriever\ class implementing \BaseRetriever\ to enable Core Memory as a retrieval source for RAG chains by translating search results into LangChain Document objects.

_core\memory/integrations/langchain · high confidence

The \core\_memory/cli/handlers\ package has been introduced to centralize and structure command-line interface logic. This change adds dedicated handler modules for graph operations (building, stats, semantic indexing, traversal, Neo4j sync), memory management (search, trace, execute, recall), metrics collection (promotions, autonomy KPIs, dreamer evaluation, longitudinal benchmarks), and integration workflows (sidecar finalization, OpenClaw onboarding, migration scripts). It also includes handlers for semantic lifecycle management (status, rebuild, doctor), operational tasks (async jobs, dreamer candidate review), store maintenance (add, query, compact, consolidate, hygiene), and setup/configuration (interactive wizard, mode presets). These handlers provide the concrete CLI entry points that route user commands to the underlying core memory, graph, and retrieval subsystems.

_core\memory/cli/handlers · high confidence

The CLI now exposes a comprehensive set of new commands for managing core memory operations. Users can perform memory searches, traces, and grounded recalls via the \memory\ command group. Graph management is expanded with commands for building, traversing, and syncing structural and semantic edges, including specific support for Neo4j shadow adapters. A new \metrics\ command group allows for deterministic aggregation of run statistics, evaluation of rationale recall, and management of agent promotion decisions (slates, KPIs, and bulk decisions). Additionally, the \ops\ command group introduces an asynchronous job queue system, enabling users to enqueue, monitor, and run background tasks such as semantic reconciliation, compaction, and Dreamer candidate management.

_core\memory/cli/parsers · high confidence

A new demo application has been introduced, providing a web-based observability and benchmarking studio for Core Memory. The demo features a chat interface backed by memory, alongside inspector tabs for Memory (beads and associations), Claims (slot state and temporal drilldown), Entities (registry and merge proposals), and Runtime (queue health and semantic backend status). It also includes an isolated Benchmark mode that runs LOCOMO-like evaluations without mutating the live store. The UI reads from canonical inspect HTTP surfaces, and the setup now supports deployment to Render with Supabase Postgres for durable persistence.

demo · high confidence

A new benchmark harness has been added to evaluate memory retrieval behavior using deterministic fixtures. It includes a runner that exercises the core memory write and retrieval paths, a reporting module that generates detailed metrics (accuracy, latency, queue observability, token usage), and a local fixture pack covering recall, contradiction, causal, and entity coreference scenarios. This allows users to validate memory system performance against defined gold-standard outcomes.

_benchmarks/locomo\like · high confidence

This change introduces a new set of Model Context Protocol (MCP) tool wrappers in the \core\_memory/integrations/mcp/tools\ directory, enabling external clients to interact with Core Memory. The tools include \capture\ for recording conversation turns, \capture\_session\ for end-of-session safety-net syncs, and \recall\ for querying memory. It also adds specialized ingest adapters for Discord, Slack, and Zoom/Otter transcripts, allowing users to import historical data from these platforms. Additionally, \sync\_transcript\_snapshot\ provides idempotent, durable state management for transcript snapshots, while \status\ exposes system health and version information.

_core\memory/integrations/mcp/tools · high confidence

This change introduces a new integration module for OpenClaw within Core Memory, enabling seamless memory capture and retrieval. It includes an agent-end bridge to process and deduplicate turn events, a hosted capture bridge to clone turns to a remote Core Memory instance, and a read bridge supporting search, trace, continuity, and session start operations. Additionally, it provides compaction and queue handling for memory flushing, a plugin installer for automatic OpenClaw configuration, and feature flags to control behavior such as summary supersession.

_core\memory/integrations/openclaw · high confidence

This change introduces a new integration module at core\_memory/integrations/pydanticai that enables PydanticAI agents to access Core Memory. It provides run wrappers (run\_with\_memory, run\_with\_memory\_sync) that automatically record agent turns and flush sessions, tool factories (memory\_search\_tool, memory\_trace\_tool, etc.) for agent-side memory retrieval, and continuity prompt injection to maintain context across turns. Additionally, it adds a PydanticAISemanticTaskRuntime that executes semantic tasks via PydanticAI agents, handling model resolution, execution, and receipt recording.

_core\memory/integrations/pydanticai · high confidence

The core\_memory/association module has been introduced to manage the full lifecycle of memory associations. It includes a crawler contract for normalizing and applying agent-authored association updates, an edge lifecycle system that records usage during recall and folds it into reinforcement metrics (reinforcement\_count, last\_reinforced\_at) to influence ranking, and a preview helper for deterministic candidate scoring. Additionally, the module provides health reporting to track association statistics and pending judge states, an SLO reporting and checking system to monitor agent-authored rates and fallbacks, and a quarantine mechanism to deduplicate and track invalid association records.

_core\memory/association · high confidence

This change introduces new schema definitions for causal-chain and Locomo-like benchmarks, including validation logic and data classes for test fixtures and gold standards. It also adds a speaker identity resolution module to map observed labels to canonical entities, and establishes stable integration ports for external orchestrators via Python APIs and an HTTP server. Additionally, it implements a new MCP protocol tool registry with typed read/write handlers, error contracts, and an optional Neo4j shadow graph adapter for visualization and inspection.

core-memory · high confidence

The examples directory now includes a comprehensive set of new demonstration scripts covering the core memory lifecycle and various integration patterns. First-touch adopters can use canonical quickstarts (canonical\_5min.py, quickstart.py) to write finalized turns and perform causal retrieval, while proof\_carry\_forward.py demonstrates how durable memory persists across sessions to change future behavior. Integrators have access to specific adapters: PydanticAI examples (pydanticai\_basic.py, pydanticai\_demo\_roundtrip.py, pydanticai\_live\_demo.py, pydanticai\_with\_memory.py) show agent integration with continuity injection and memory tools; an HTTP/SpringAI client example (http\_springai\_client.py) exercises REST endpoints for write, search, trace, and continuity; and an OpenClaw bridge demo (openclaw\_bridge\_demo.py) illustrates stdin/stdout JSON dispatch for agent and read bridges. Additionally, claim\_layer\_demo.py showcases the experimental claim layer's write, update, and resolution flows, and store\_compat\_quickstart.py provides a direct MemoryStore workflow for advanced users.

examples · high confidence

A new benchmark harness has been added to evaluate the system's ability to retrieve information based on causal connections rather than pure semantic similarity. This tool measures whether the system can correctly identify root causes in synthetic histories, specifically testing its ability to ignore semantically similar but causally irrelevant 'distractor' data. The benchmark provides metrics such as edge precision/recall, grounding completeness, and a headline 'distractor survival rate' to quantify how well causal traversal outperforms standard vector similarity.

benchmarks/causal · high confidence

Adds a new \benchmarks/causal\_continuity\ package that composes five benchmark tasks (T1 causal-chain reconstruction, T2 calibration reliability, T3 temporal state selection, T4 longitudinal continuity, and T5 thread fidelity) into a single report. The suite introduces a command-adapter protocol for external T1 comparators, an evidence-attestation system to gate public claims, and a claim-certificate mechanism that validates report readiness against an evidence manifest. It also includes an ablation matrix builder to measure mechanism ownership by comparing full runs against ablated configurations, along with deterministic fixtures and judges for offline testing.

_benchmarks/causal\continuity · high confidence

This change introduces a new entity management layer within the core memory system, providing domain-facing interfaces for entity registration, alias normalization, and merge proposal workflows. It adds deterministic quality checks to filter out generic or invalid entity labels, ensuring curated data integrity. Additionally, it implements entity-aware retrieval logic that allows queries to be expanded with relevant entity aliases and enables scoring of memory beads based on entity matches, thereby improving the precision of information recall through graph-based entry points rather than relying solely on embedding similarity.

_core\memory/entity · high confidence

The eval directory now includes a comprehensive suite of new scripts and fixtures to validate core memory capabilities. This adds a behavioral evaluation scaffold (DR-7) to track metrics like accepted candidate rates and cross-session transfer success, alongside a longitudinal benchmark (PV-1) to measure performance lifts over a no-memory baseline. Retrieval quality is now assessed via a new KPI set and a dedicated retrieval eval script that enforces deterministic results, measures recall at 5, and verifies causal grounding. Paraphrase robustness is tested using a new fixture pack and evaluation script to ensure consistency across query variations. Additionally, an A/B comparison harness allows side-by-side testing of the new typed search against the legacy memory reason tool, while a migration drill script validates the idempotency of the store migration process.

eval · high confidence

Introduces a new \core\_memory/runtime/observability\ package that provides structured telemetry and quality metrics for the Core Memory system. This includes an \observability\ module for emitting structured JSON logs and tracking in-memory counters and timings for operations like bead management and queries. It adds specific quality meters: a \myelination\ module that computes edge and bead bonuses based on retrieval feedback and audited reward events; a \tension\_meter\ that tracks the lifecycle and resolution rates of tension candidates; a \self\_model\_drift\ module that flags ungrounded identity updates or contradictions; and a \reviewer\_quick\_value\ module for evaluating retrieval improvements. The package also exposes compatibility import paths for calibration, retrieval feedback, and value overrides, centralizing these runtime insights.

_core\memory/runtime/observability · high confidence

This change introduces a dedicated policy module in core\_memory/policy that governs how conversation turns are processed into memory beads. It adds a semantic bead-type classifier (bead\_typing.py) that routes turns into specific types like decision, goal, or lesson using an LLM-based task runtime with a conservative heuristic fallback, while explicitly preventing retrieval questions from being promoted as durable memory. The module includes a bead field judge (bead\_judge.py) for validating and normalizing bead content, association contract logic (association\_contract.py) for managing relationships between beads, and a delegated semantic authoring path (turn\_memory\_authoring.py) that allows agents to author or repair memory updates under strict grounding and authority boundaries. Additional policy helpers handle hygiene (hygiene.py), incident tagging (incidents.py), and semantic task verification (semantic\_task\_verifier.py) to ensure outputs are safe and compliant before being persisted.

_core\memory/policy · high confidence

This change introduces a new \core\_memory/runtime/queue\ package that provides the infrastructure for asynchronous background tasks. It includes a compaction queue for managing memory flushes, a side-effect queue for handling integration tasks (such as Dreamer analysis, Neo4j synchronization, and health recomputation), and a jobs module that exposes read-only status surfaces for these queues. This allows operators to inspect the state of background work, including queue depth, retry status, and circuit-breaker states, without coupling to the underlying implementation details.

_core\memory/runtime/queue · high confidence

This change introduces a suite of new operational scripts to the \scripts/\ directory. It adds \openclaw\_bridge\_ci\_smoke.sh\ and \openclaw\_bridge\_doctor.sh\ to validate and diagnose the OpenClaw bridge integration, alongside \openclaw\_bridge\_install.sh\ for hardened plugin installation. It also includes \run\_contributor\_smoke.sh\ for end-to-end contributor verification, \verify\_pypi\_mcp.py\ to test the PyPI wheel and MCP tool surface, \audit\_store\_delegation.py\ to classify persistence functions, and baseline JSON files (\architecture\_guards\_baseline.json\, \compat\_surface\_usage\_baseline.json\) to enforce architectural and compatibility constraints.

scripts · high confidence

Users can now sync Core Memory data to an Obsidian vault by setting the CORE\_MEMORY\_SYNC\_TARGETS=obsidian environment variable and configuring CORE\_MEMORY\_OBSIDIAN\_VAULT. The integration writes beads as Markdown files with YAML frontmatter and maintains wikilinks for associations. It also supports searching the vault via the Obsidian Local REST API when CORE\_MEMORY\_OBSIDIAN\_REST\_URL is provided.

_core\memory/integrations/obsidian · high confidence

An optional Neo4j integration has been added to Core Memory, strictly limited to projection-only operations for visualization, graph inspection, debugging, and demo tooling. This adapter syncs local bead and association data to a Neo4j graph database but does not participate in canonical read/write runtime paths, ensuring that Core Memory's local storage remains the source of truth and that Neo4j availability never blocks core functionality.

_core\memory/integrations/neo4j · high confidence

A new SpringAI bridge integration has been added to the core memory system, providing a specific entrypoint for SpringAI deployments. This change introduces a new \springai\ package that wraps the existing generic HTTP implementation, allowing the application to be deployed via SpringAI while maintaining compatibility with standard HTTP deployments. The bridge is currently marked as beta and functions as an HTTP bridge rather than a native runtime extension.

_core\memory/integrations/springai · high confidence

A new stable integration layer has been added to expose core memory capabilities to external systems. This includes a public contract for agent-authored bead authorship, a shared recall payload handler that ensures identical semantics across HTTP and MCP wire surfaces, and utility functions for rebuilding turn indexes and backfilling bead session IDs. Additionally, optional Neo4j synchronization adapters are now available for graph visualization and inspection.

_core\memory/integrations · high confidence

The \tools/mem-beads\ directory has been cleaned up by removing the \core\_memory\ subpackage (including its CLI, data models, event system, and store implementation) and several standalone scripts (\associate.py\, \consolidate.py\, \extract-beads.py\, \install.sh\, and the \mem-beads\ wrapper). This eliminates the legacy memory management and association analysis capabilities from this location, leaving only the core \mem\_beads\ package.

tools · high confidence

The \.piper/start-tts.sh\ script, which previously managed the local Piper TTS server process (including health checks and auto-restart logic), has been removed. Users relying on this script to start or monitor the TTS service locally will no longer have this automation available in this directory.

.piper · high confidence

The post-write logic for bead commits has been consolidated into a dedicated runtime module. When a bead is saved, the system now automatically mirrors the data to configured backends—including vector search (Qdrant), graph storage (Kuzu), and external sync targets—and optionally enqueues association coverage updates. This ensures that semantic search, graph relationships, and external integrations are updated immediately after a bead is persisted.

_core\_memory/runtime/post\write · high confidence

This release completes the agent-led semantic write integrity rollout, enforcing schema-owned full authorship, bounded derived turn memories, and governed append-only reauthoring with hard-mode degradation. It introduces new maintenance actions (\reauthor\_memory\, \retry\_pending\_semantic\, \semantic\_backfill\_report\) and aligns the public API with Recall v2, exposing cited section-to-chunk records under \hydration.data\ in stable \RecallResult\ responses. Evidence-only semantic indexing now resolves and deduplicates chunk hits to visible parent document-section beads before reranking. The codebase also undergoes significant structural cleanup: Phase 9h deletes 52 backward-compat shims and migrates all callsites to canonical subpackage paths (e.g., \runtime/\, \integrations/openclaw/\, \core\_memory/cli/\), while Phase 9g fixes a layering violation in the retrieval pipeline by converting top-level imports to lazy function-level imports. Several private duplicate modules and compatibility shims (e.g., \session\_enrichment\_delta\, \goal\_lifecycle\, \write\_ops\, \explain.build\_explain\) are removed.

(repo-wide) · high confidence

The core memory graph implementation has been reorganized from a single monolithic module into a set of focused submodules (structural, traversal, semantic, junctions, roadmap, root\_cause, worldlines, storylines) while preserving the legacy import paths via a compatibility facade. This change introduces a unified causal scoring system in edge\_weights.py that applies relationship-specific hop weights, provenance trust factors, and lifecycle multipliers (reinforcement and decay) to all graph traversals, ensuring consistent ranking across backends. It also enforces strict provenance validation for structural and semantic edges, restricts allowed provenance sources, and adds a claims-first junction projection for roadmap retrieval that derives recurring memory locations from canonical claims and entity worldlines without writing associations.

_core\memory/graph · high confidence

The core\_memory/cli module now provides a unified command-line interface organized into distinct command families: setup (init, doctor, paths), config (show, set, validate), store (add, stats, compact, uncompact, consolidate, rolling-window), recall (search, heads, trace), inspect (list, stats, health), ingest, demo, and integrations. This new structure replaces legacy entry points while maintaining backward compatibility through a compatibility layer that transparently rewrites old command patterns (such as dev memory) into the new canonical forms, ensuring existing automation scripts continue to function without modification.

_core\memory/cli · high confidence

The \core\memory/runtime\ module is introduced, providing the central execution engine for memory operations. This change implements a lazy-loading namespace package (\\\init\\_.py\) to reduce import overhead by requiring direct submodule imports. The new \engine.py\ establishes the runtime logic for processing turns and sessions, featuring a significant behavioral shift where bead writes are now subject to LLM-based judgment (via \judge\_bead\_fields\) to ensure quality and correctness, including support for multi-speaker turns and fallback mechanisms. Additionally, the module includes \event\_schemas.py\ to maintain backward compatibility with legacy event schema constants while canonical definitions reside in the schema layer.

_core\memory/runtime · high confidence

The write pipeline now uses a new pluggable tokenizer module that estimates token counts via tiktoken, Hugging Face transformers, or a configurable character ratio, replacing the previous simple length-based heuristic. This enables more accurate rolling-window budgeting for memory consolidation. The pipeline also introduces a continuity injection mechanism that prioritizes the canonical rolling record store for runtime context, ensuring consistent session continuity.

_core\_memory/write\pipeline · high confidence

The \core\_memory/runtime/semantic\_tasks\ module has been added to provide a stable compatibility layer for semantic task operations. This location re-exports core contracts (such as task types and model profiles), runtime helpers (including the provider and disabled runtime implementations), receipt persistence functions, and output verification logic from their underlying policy and schema modules. This change centralizes access to these components for runtime code, ensuring that policy and retrieval logic can interact with semantic tasks without creating upward import dependencies.

_core\_memory/runtime/semantic\tasks · high confidence

The memory engine now enforces a semantic barrier during the flush process, ensuring that only the latest finalized turn with a 'committed' status (or an explicit waiver) is included in the flush cycle; turns pending semantic writes are blocked to maintain data integrity. Additionally, the system now records idempotent process\_flush checkpoint beads to track the exact state of each flush operation, preventing duplicate processing for the same turn and providing a clear audit trail of flush transactions.

_core\memory/runtime/flush · high confidence

This change establishes the definitive schema layer for core memory by adding a new \core\_memory/schema\ package. It defines the \AgentAuthoredBeadV1\ and \AgentAuthoredAssociationV1\ contracts that serve as the single source of truth for agent-authored turn memories, replacing parallel field lists. The update introduces a unified \build\_retrieval\_text\ function for vector indexing that now includes association-anchor fields (such as entities, topics, and keys) to improve retrieval quality. It also implements a new promotion scoring system with type-specific priors and adaptive thresholds, a confidence classification system (C/B/A) with legacy migration paths, and a storyline overlay validation layer to enforce traceability for interpretive records.

_core\memory/schema · high confidence

The \core\_memory/retrieval/pipeline\ module now provides a unified, canonical entry point for memory search, replacing legacy typed-form shims with a request-normalization layer that standardizes query inputs (e.g., \query\_text\, \intent\, \k\) and exposes detailed explainability diagnostics. A key behavioral change is the integration of causal graph traversal: when \require\_structural\ is enabled, the pipeline appends relation chains to search results, with traversal depth, seed breadth, and chain-merge budgets now configurable via environment variables (\CORE\_MEMORY\TRACE\\*\) to improve recall convergence. The pipeline also includes a catalog-based form snapping mechanism for legacy compatibility, ensuring that incident IDs, topics, and relation types are matched against known canonical values before execution.

_core\memory/retrieval/pipeline · high confidence

The runtime now includes a dedicated \passes\ package that enforces strict contracts for agent-authored turn-memory updates, invokes configurable crawler agents with retry logic, and executes post-write enrichment stages (association, claim extraction, decision/promotion, and quality metrics) via an asynchronous side-effect queue. This shifts semantic write validation and enrichment from the synchronous event pipeline to a durable, idempotent background process, ensuring that agent contributions are validated against defined schemas before being applied to memory.

_core\memory/runtime/passes · high confidence

The session runtime now exposes a dedicated persistence surface and new lifecycle modules. \live\_session.py\ reads session beads primarily from the append-only session surface, falling back to the legacy index only when the \CORE\_MEMORY\_LIVE\_SESSION\_ALLOW\_INDEX\_FALLBACK\ environment variable is set. \session\_start\_flow.py\ initializes sessions by creating a \session\_start\ bead that includes a continuity snapshot and injects SOUL working-memory data (referenced as §4.3). \goal\_lifecycle.py\ introduces a deterministic heuristic pass that identifies candidate goal resolutions based on shared tags and token overlap, returning structured recommendations rather than automatically advancing goal states. \session\_enrichment\_delta.py\ provides a new normalization and deduplication layer for session enrichment deltas, defining specific row limits and canonical relationship types.

_core\memory/runtime/session · high confidence

The legacy one-shot seed-quality backfill mechanism has been retired and replaced with a read-only compatibility census. The \run\_seed\_quality\_backfill\ function in \core\_memory/runtime/hygiene/seed\_backfill.py\ now scans existing store data to report on entity quality and thin beads but strictly rejects any \apply=True\ requests. Instead of mutating stored beads, the system now returns an error directing users to use the governed \reauthor\_memory\ action for semantic maintenance, ensuring that data changes follow the new append-only contract.

_core\memory/runtime/hygiene · high confidence

The test suite has been reorganized into a flat directory structure with a new README that maps filename prefixes to subsystems (schema, persistence, domain graph, retrieval, runtime, integrations, etc.) to help developers locate and run focused test subsets. A new conftest.py disables semantic autodrain globally to prevent test teardown failures, and several new test files have been added to verify adapter contract markers, agent-authored write integrity, and runtime gate behaviors.

tests · high confidence

The project has been reorganized to promote the 'mem-beads' tool into a new root-level 'core-memory' package (version 1.1.1), which now serves as the primary Python distribution. This new package includes extensive optional dependencies for various backends (such as Neo4j, Qdrant, and MCP) and tools, replacing the previous 'mem-beads' package located in 'tools/mem-beads'. Additionally, the project license has been switched from MIT to Apache-2.0, and a new Node.js plugin 'core-memory-bridge' has been introduced to integrate with OpenClaw.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 60 → 67 (+7.1)
• Rubric changed (rubric-2026.08.17 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 57 → 73 (+15.7)
• Architecture 100 → 81 (-18.4)
• Maturity 70 → 78 (+8.5)
• Readiness 55 → 58 (+3.2)
• Security 63 → 74 (+10.9)

• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — no supported dependency manifest was read
• Duplicated block (10 lines × 2) (core_memory/claim/retrieval_planner.py)
• Duplicated block (10 lines × 2) (core_memory/integrations/mcp/tools/ingest_discord.py)
• Duplicated block (10 lines × 2) (core_memory/integrations/openclaw/agent_end_bridge.py)
• Duplicated block (10 lines × 2) (core_memory/persistence/store_retrieval_context.py)
• Duplicated block (10 lines × 2) (core_memory/provider_config.py)
• Duplicated block (10 lines × 2) (core_memory/retrieval/adapters/pipehouse_adapter.py)
• Duplicated block (10 lines × 2) (core_memory/retrieval/pipeline/canonical.py)
• Duplicated block (10 lines × 2) (core_memory/runtime/observability/reviewer_quick_value.py)
• Duplicated block (10 lines × 3) (core_memory/persistence/retrieval_feedback.py)
• Duplicated block (10 lines × 4) (core_memory/graph/storylines.py)
• Duplicated block (10 lines × 4) (core_memory/runtime/dreamer/convergence.py)
• Duplicated block (10 lines × 5) (core_memory/persistence/retrieval_feedback.py)
• Duplicated block (10–11 lines × 2) (core_memory/integrations/openclaw/agent_end_bridge.py)
• Duplicated block (10–11 lines × 2) (core_memory/persistence/backend.py)
• Duplicated block (10–11 lines × 2) (core_memory/runtime/associations/coverage.py)
• Duplicated block (11 lines × 2) (core_memory/persistence/store_reporting.py)
• Duplicated block (11 lines × 2) (core_memory/persistence/store_text_hygiene_ops.py)
• Duplicated block (11 lines × 2) (core_memory/retrieval/pipeline/canonical.py)
• …and 294 more

• Change coupling: server.py ↔ side_effect_queue.py (core_memory/integrations/http/server.py)
• Dependency hygiene PARTLY measured — Python dependencies read, no exact pin to grade for currency
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Documentation: written for insiders (docs/integrations/springai/README.md)
• Duplicated block (10 lines × 2) (core_memory/integrations/openclaw/agent_end_bridge.py)
• Duplicated block (10 lines × 2) (core_memory/persistence/metrics_ops.py)
• Duplicated block (10 lines × 2) (core_memory/retrieval/adapters/pipehouse_adapter.py)
• Duplicated block (10 lines × 2) (core_memory/runtime/dreamer/eval.py)
• Duplicated block (10 lines × 3) (core_memory/association/crawler_contract.py)
• Duplicated block (10 lines × 3) (core_memory/persistence/retrieval_feedback.py)
• Duplicated block (10 lines × 4) (core_memory/runtime/dreamer/convergence.py)
• Duplicated block (10 lines × 6) (core_memory/persistence/myelination_rewards.py)
• Duplicated block (10–11 lines × 2) (core_memory/retrieval/semantic_index.py)
• Duplicated block (11 lines × 2) (core_memory/claim/retrieval_planner.py)
• Duplicated block (11 lines × 2) (core_memory/persistence/events.py)
• Duplicated block (11 lines × 2) (core_memory/persistence/store_reporting.py)
• Duplicated block (11 lines × 2) (core_memory/persistence/store_retrieval_context.py)
• Duplicated block (11 lines × 2) (core_memory/runtime/dreamer/eval.py)
• Duplicated block (11 lines × 2) (scripts/check_architecture_guards.py)
• …and 445 more

• 18 commits — 15 feature/other, 3 fixes

• core_memory/runtime — 5 commits
• docs/PRD — 5 commits
• (root) — 2 commits
• core_memory/retrieval — 2 commits
• core_memory/init.py — 1 commit
• core_memory/association — 1 commit
• core_memory/graph — 1 commit
• core_memory/policy — 1 commit

• fix: Fix bead->storyline->goal quality chain: naming, goal apply, external enrichment (#415)
• fix: Fix delegated semantic runtime credential routing (#422)
• fix: Seed-quality backfill: one-shot cleanup of pre-fix stores (SEED_BACKFILL_ONESHOT) (#416)
• change: Add engineering simplicity guiding principle to CLAUDE.md (#414)
• change: Improve agent-judged causal association quality (#417)
• change: chore: prepare agent-led rollout release (#419)
• change: docs: add PALMER PER and junction roadmap retrieval PRD (#420)
• change: docs: complete PER roadmap frontier and edge-cost contract (#421)
• change: docs: keep roadmap PRD product-neutral (#423)
• change: docs: mark roadmap watershed attribution shipped (#441)
• change: docs: reconcile status with current master (#439)
• change: feat(goals): add reviewed goal progress edges (#433)
• change: feat(retrieval): add bounded causal segment search (#431)
• change: feat(retrieval): add claims-first junction projection (#429)
• change: feat(retrieval): add roadmap query planner (#436)
• change: feat(retrieval): add roadmap watershed attribution (#438)
• change: feat(retrieval): build durable junction roadmap (#434)
• change: feat: add governed semantic reauthoring (#418)

• Unchanged — 0 containers · 1 contexts · 0 edges

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

JohnnyFiv3r/Core-Memory was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.