memfg 6.0.0__py3-none-any.whl

memfg-6.0.0.dist-info/METADATA

@@ -0,0 +1,322 @@
+Metadata-Version: 2.4
+Name: memfg
+Version: 6.0.0
+Summary: Lossless Context Management for Recursive Language Model
+Author: MemoryForge Contributors
+License: MIT
+License-File: LICENSE
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Requires-Python: >=3.10
+Requires-Dist: anyio>=4.0
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: tomli>=2.0; python_version < '3.11'
+Provides-Extra: all
+Requires-Dist: fastembed>=0.5.0; extra == 'all'
+Requires-Dist: matplotlib>=3.7; extra == 'all'
+Requires-Dist: mypy>=1.10; extra == 'all'
+Requires-Dist: pandas>=2.0; extra == 'all'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'all'
+Requires-Dist: pytest-cov>=5.0; extra == 'all'
+Requires-Dist: pytest>=8.0; extra == 'all'
+Requires-Dist: ruff>=0.9; extra == 'all'
+Requires-Dist: tqdm>=4.0; extra == 'all'
+Requires-Dist: twine>=5.0; extra == 'all'
+Provides-Extra: benchmark
+Requires-Dist: matplotlib>=3.7; extra == 'benchmark'
+Requires-Dist: pandas>=2.0; extra == 'benchmark'
+Requires-Dist: tqdm>=4.0; extra == 'benchmark'
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.9; extra == 'dev'
+Requires-Dist: twine>=5.0; extra == 'dev'
+Provides-Extra: embeddings
+Requires-Dist: fastembed>=0.5.0; extra == 'embeddings'
+Description-Content-Type: text/markdown
+
+# MemoryForge
+
+MemoryForge is a local-first memory layer for Codex CLI workflows.
+
+It stores durable project evidence in SQLite, keeps live context bounded, and
+returns source-backed context bundles to the model the user is already running.
+MemoryForge is not a separate answering agent and it is not a codebase AST graph
+engine. The host model answers; MemoryForge supplies memory, references, and
+provenance.
+
+```text
+User -> Codex CLI -> MemoryForge MCP -> SQLite memory.db
+                         |
+                         +-> bounded CoreContextBundle
+                         +-> optional RLM/LCM worker runs
+```
+
+## What It Is For
+
+MemoryForge focuses on long-form project evidence that is common in real coding
+workflows but too large or noisy to paste into every prompt:
+
+- design notes and architecture documents
+- requirements and implementation plans
+- setup guides and decision records
+- benchmark descriptions and experiment logs
+- large Markdown files used while "vibe coding" or building a project over many sessions
+
+These sources are ingested through RLM, stored as durable LTM evidence, and
+recalled as bounded context when Codex needs them.
+
+MemoryForge intentionally avoids a large AST/code graph schema in the core
+release. Source files can still be stored as RLM/LTM evidence, but dedicated
+code indexing is future work rather than part of the current SQLite schema.
+
+## Memory Layers
+
+| Layer | Role | Model worker use |
+| --- | --- | --- |
+| RLM | Raw Large Memory. Chunks large files/prompts and indexes them into durable memory. | Optional, for batch analysis. |
+| LTM | Long-Term Memory. Recalls durable evidence across sessions and sources. | No model call. |
+| LCM | Lossless Context Management Keeps the active session view bounded with summaries and refs. | Optional, for compaction. |
+
+Important boundary: LCM compacts MemoryForge's SQLite-backed active context. It
+does not directly erase Codex's own context window. Codex manages its live
+thread and can compact it with `/compact`; MemoryForge hooks and MCP tools then
+help preserve and rehydrate the evidence needed after compaction.
+
+## Install
+
+From PyPI in a project that uses `uv`:
+
+```bash
+uv add memfg
+```
+
+With optional local embeddings:
+
+```bash
+uv add "memfg[embeddings]"
+```
+
+For local development from this repository:
+
+```bash
+uv sync --extra dev --extra benchmark
+```
+
+## Initialize A Codex Project
+
+Run this at the project root:
+
+```bash
+uv run memoryforge init . --agent-id default --force
+```
+
+This creates:
+
+```text
+.memoryforge/memory.db
+.memoryforge/config.json
+.memoryforge/hooks/memoryforge-hook.sh
+.codex/config.toml
+.codex/hooks.json
+```
+
+The Codex config registers the MemoryForge MCP server:
+
+```toml
+[mcp_servers.memoryforge]
+command = "uv"
+args = ["run", "memoryforge-mcp"]
+
+[mcp_servers.memoryforge.env]
+MEMORYFORGE_DB = "/absolute/path/.memoryforge/memory.db"
+```
+
+The hook file records prompt and compaction lifecycle events. Project-local
+Codex hooks only run after the project `.codex/` layer is trusted by Codex.
+Inspect and trust them in the CLI with `/hooks` if Codex asks.
+
+## Prompt Submit, Cancel, And Retract
+
+MemoryForge uses a two-phase hook flow for user prompts:
+
+- `UserPromptSubmit` writes the latest prompt for the session to
+  `.memoryforge/pending/`.
+- `Stop` commits that pending prompt into SQLite, then RLM/LTM/LCM processing
+  can run.
+- `SessionStart` removes stale pending prompts after the local TTL.
+
+This keeps interrupted turns out of durable memory when the Codex turn is
+cancelled before `Stop` runs. MemoryForge does not infer cancellation from
+free-form hook payload fields such as status or reason strings; that is too
+fragile across Codex versions and locales. Explicit retract integrations should
+call the internal `discard-pending` hook event for the matching session before a
+later `Stop` can commit it.
+
+## Basic Usage
+
+Ingest a long Markdown file or project document:
+
+```bash
+uv run memoryforge --db .memoryforge/memory.db ingest-file docs/notes.md \
+  --agent-id default
+```
+
+Load a large source through RLM:
+
+```bash
+uv run memoryforge --db .memoryforge/memory.db rlm-load docs/design.md \
+  --agent-id default \
+  --name design-notes
+```
+
+Recall durable evidence:
+
+```bash
+uv run memoryforge --db .memoryforge/memory.db recall-memory \
+  --agent-id default \
+  --query "why did we choose sqlite"
+```
+
+Build a runtime context bundle for the active Codex project:
+
+```bash
+uv run memoryforge --db .memoryforge/memory.db runtime-context \
+  --agent-id default \
+  --session-id session-1 \
+  --query "what context should Codex use now" \
+  --project-root .
+```
+
+Run LCM compaction over MemoryForge's stored active context:
+
+```bash
+uv run memoryforge --db .memoryforge/memory.db lcm-compact \
+  --agent-id default \
+  --session-id session-1 \
+  --project-root . \
+  --force
+```
+
+Run the MCP server directly:
+
+```bash
+uv run memoryforge-mcp
+```
+
+## Optional Vector Recall
+
+MemoryForge works without embeddings by using lexical/FTS retrieval. To enable
+semantic recall, install the embeddings extra and choose FastEmbed:
+
+```bash
+uv add "memfg[embeddings]"
+
+export MEMORYFORGE_VECTOR_BACKEND=fastembed
+export MEMORYFORGE_VECTOR_MODEL=BAAI/bge-small-en-v1.5
+export MEMORYFORGE_REQUIRE_VECTOR_MODEL=1
+```
+
+The project intentionally keeps one vector cache table, `vec_index`, and avoids
+SQLite extension backends such as `sqlite-vec` in the core release. This keeps
+the package easier to install, test, and publish.
+
+## CLI Surface
+
+Public commands:
+
+- Project/runtime: `init`, `mcp-server`, `runtime-context`
+- Conversation memory: `store-session`, `search`, `recall-memory`, `active-recall`, `long-term-source`
+- Contradictions: `record-contradiction`, `find-contradictions`
+- LCM: `lcm-context`, `lcm-compact`, `lcm-maintain`
+- RLM/source loading: `ingest-file`, `rlm-load`, `rlm-search`, `rlm-chunk-get`, `dispatch`, `context-get`, `rlm-record`, `aggregate`, `rlm-run`
+- Diagnostics: `chunk`, `benchmark`
+
+`memoryforge hook` is an internal Codex hook endpoint created by `memoryforge init`.
+RLM/LCM sub-agents are internal MemoryForge workers. For real worker runs,
+MemoryForge uses Codex CLI through `codex exec` when configured. Development-time
+Codex host subagents are separate review/triage helpers and are not the
+MemoryForge runtime worker API.
+
+## Benchmarks
+
+The current benchmark focus is long-memory behavior, not static code indexing:
+
+- LoCoMo
+- LongMemEval
+- deterministic multi-session stress benchmark
+- synthetic smoke benchmark
+
+Example smoke check:
+
+```bash
+uv run python benchmarks/synthetic_test.py
+```
+
+Stress check for many real SQLite sessions:
+
+```bash
+uv run python benchmarks/stress_sessions.py \
+  --sessions 100 \
+  --turns-per-session 12 \
+  --output benchmarks/results/stress_sessions_100x12.json
+```
+
+Real LoCoMo and LongMemEval runs require their datasets and model credentials.
+See [docs/BENCHMARKS.md](docs/BENCHMARKS.md) for run modes and result fields.
+
+## Development
+
+Run the normal quality gate on Unix-like shells:
+
+```bash
+make check
+```
+
+Equivalent commands:
+
+```bash
+uv run ruff check memoryforge tests benchmarks
+PYTHONDONTWRITEBYTECODE=1 uv run mypy memoryforge
+PYTHONDONTWRITEBYTECODE=1 PYTHONPATH=. uv run pytest --ignore=tests/test_real_subagents.py --cov=memoryforge --cov-report=term-missing --cov-fail-under=77
+MEMORYFORGE_REAL_SUBAGENT=1 MEMORYFORGE_REAL_PROJECT_ROOT="$PWD" MEMORYFORGE_SUBAGENT_RUNNER=codex MEMORYFORGE_MODEL=gpt-5.4 uv run pytest tests/test_real_subagents.py -vv
+uv build
+uv run twine check dist/*
+```
+
+On Windows PowerShell, keep pytest temp/cache paths in writable directories:
+
+```powershell
+$env:TMP='C:\tmp'; $env:TEMP='C:\tmp'
+Remove-Item Env:\MEMORYFORGE_SUBAGENT_RUNNER -ErrorAction SilentlyContinue
+Remove-Item Env:\MEMORYFORGE_MODEL -ErrorAction SilentlyContinue
+uv run pytest --ignore=tests/test_real_subagents.py --basetemp=C:\tmp\memoryforge-pytest-basetemp -o cache_dir=.tmp\pytest-cache
+
+$env:MEMORYFORGE_REAL_SUBAGENT='1'; $env:MEMORYFORGE_REAL_PROJECT_ROOT=(Get-Location).Path
+$env:MEMORYFORGE_SUBAGENT_RUNNER='codex'; $env:MEMORYFORGE_MODEL='gpt-5.4'
+uv run pytest tests/test_real_subagents.py -vv --basetemp=C:\tmp\memoryforge-pytest-basetemp-real -o cache_dir=.tmp\pytest-cache-real
+```
+
+The real Codex sub-agent smoke tests are local-only. Run them on a machine with the Codex CLI installed and authenticated if you want to verify `runner="codex"`; they are not part of CI/CD. Mock runners are only for targeted unit tests that verify MemoryForge's own control flow.
+
+## Release Notes For Maintainers
+
+Before pushing or publishing:
+
+1. Keep generated data out of the release: `.venv/`, caches, `.coverage`, `.memoryforge/`, `.codebase-memory/`, `dist/`, and `benchmarks/results/`.
+2. Run the full gate on Python 3.10, 3.11, and 3.12 through CI.
+3. Build the wheel and sdist with `uv build`.
+4. Check distributions with `twine check`.
+5. Prefer the `Publish` GitHub workflow with PyPI trusted publishing. Direct maintainer uploads may use `twine upload` with `TWINE_USERNAME=__token__` and `TWINE_PASSWORD` supplied from the shell environment, never from a committed config file.
+
+## Documentation
+
+- [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md)
+- [docs/BENCHMARKS.md](docs/BENCHMARKS.md)
+- [docs/API.md](docs/API.md)
+- [docs/RLM.md](docs/RLM.md)
+- [docs/SECOND_BRAIN_ROADMAP.md](docs/SECOND_BRAIN_ROADMAP.md)

memfg-6.0.0.dist-info/RECORD

@@ -0,0 +1,84 @@
+memoryforge/__init__.py,sha256=Y2N-7jndH6PECyEoxwMMjeD-fegxmIlOik9uUrqhwYE,1030
+memoryforge/_core.py,sha256=jnWFg3KrmiRaWQO7zPzNtk5GzMNaRjtSDjizD0RK54c,13893
+memoryforge/py.typed,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+memoryforge/runtime.py,sha256=WwO9zk5moAdd5DINOpk5tNQ9_UXXnHaIJlj5Hq6BPxw,7820
+memoryforge/agents/__init__.py,sha256=25f50mWL3iYK8oiDTyxMF_hy-Pxp6K-XntYtb1H2zDQ,748
+memoryforge/agents/codex_sync.py,sha256=elvZR2QZur31hZ7dEy5GkqQCESG4XUycAUzS54YU6KA,4609
+memoryforge/agents/operators.py,sha256=zrybrpTs5t_D8mZlECL21NnbkJSj_25CF5iRpg3DlEE,10034
+memoryforge/agents/runners.py,sha256=QaCHZhwdcqJG-mJRCiI3MxrhT6IUpjPo7lv94DvYxp4,18548
+memoryforge/agents/subagents.py,sha256=OoxihEUkLqV8NL4-syYE-ILT11FssnXerUK3gykD1rk,876
+memoryforge/api/__init__.py,sha256=Cvtz83cvGpLzs7JVStaDPar6dY2Tw0j3Pkz2yYxzzac,190
+memoryforge/api/active_recall.py,sha256=LgtDpsrGZbIPtvR-eZiS4T1gsCsAkqmC9WJcHdeo58s,7617
+memoryforge/api/app.py,sha256=5VkqXWR5ieZXImTsmUT0e9cEF-4UxqqXzQ2L0ncW3tU,3481
+memoryforge/api/context_assembly.py,sha256=5TLM3mrJ284tiILamO59yGpgPoc7qBq0WIEQyQk2QaM,4719
+memoryforge/api/context_builder.py,sha256=rjVz-D2xkJmusOsUeQPcA0JGpIW6V9YnIcTeHsiSwI4,26508
+memoryforge/api/context_bundle.py,sha256=GftUPQZvu_tYbNh6UDgTDic7hVReJ2No2tQH3opATZM,1568
+memoryforge/api/lcm_facade.py,sha256=pWrdX3zLUCu5zPMm0isEeljvSUznQytrHM1l25sXOfE,7038
+memoryforge/api/lifecycle.py,sha256=Hhid44Ib6tY1-fJb75F55KH8acNiTuhrcSATTlsc4OI,15943
+memoryforge/api/memory_io.py,sha256=1z3aYLB-xpDubG8Oc2U5XUbnlJERwESDl91mHUX5nio,9150
+memoryforge/api/rlm_facade.py,sha256=8olxDARN_wB0al_BBqwApqAg89Fun1nytmOZpwSxmig,13826
+memoryforge/benchmark/__init__.py,sha256=rf2oMdrFRyXMRj8vsZW-LZVXffxFt0wzOp9zha51GNI,540
+memoryforge/benchmark/adapter.py,sha256=jDjnoeWtHbxjP1PuiSgOT0AOF9JtBz9dSrFMfKc5isk,3009
+memoryforge/benchmark/locomo.py,sha256=eKAjcBfwBzzdHX7fvpxJ8JV0EEuPAwABlLNhZ_qoGX4,6739
+memoryforge/benchmark/longmemeval.py,sha256=exk6WbPiTNxUGlRQET00qv_AzouolnOhOqNlHBjf4No,4239
+memoryforge/benchmark/secondbrain.py,sha256=-dUd1hqrviIWvvrtSZElLzzn0K2ZVdK2aE9kt_ZbiVY,24311
+memoryforge/cli/__init__.py,sha256=2x33Pu-eWhi68PWsnfV04YImluZGjY6hA6K3h3ZkTbA,125
+memoryforge/cli/commands.py,sha256=MWbWay2h9LurlUF_3KMfRSt0sJmkQQzkXIZlAvxC7ZI,14563
+memoryforge/cli/main.py,sha256=ouzJzeVjyhQ541Iywa3_URZOaSrNHimcmamYn5T_Gws,346
+memoryforge/cli/parser.py,sha256=5b9ckm3fReDTSZNYg0b_cQWeSHBlZIOBVAxYDgvh7DU,13663
+memoryforge/db/__init__.py,sha256=_HbRHIcsJy4tLQSvJnjL0nFXQcIFiV5l06jXnFLT8eo,184
+memoryforge/db/schema.py,sha256=DSHoKezOqv4WkRWil-Y2tTXZIzgP6-GYto3X_DY7fP4,9926
+memoryforge/init/__init__.py,sha256=1OwGbZQeDG3cHHfN352gyH6ZnuH-ZpdXZUe2WH7kOos,205
+memoryforge/init/bootstrap.py,sha256=cY-6TpfweC7Ye4Mg5QNztrcrL5LkLrXke7poLW6Cmrg,4372
+memoryforge/init/codex.py,sha256=NWemoGQ0_vZD23Iphspbuwwinfcb0e9WZ8AFklPQ_7Q,11858
+memoryforge/init/hooks.py,sha256=pTX65QInrlbzRommqrKnQA6S7rAfBlXZZEXvjzCnZbE,8332
+memoryforge/lcm/__init__.py,sha256=zIUz71DZ0XgYRpApoMGoqJDkpreJdcHMLXNFihjWL7A,1505
+memoryforge/lcm/compaction/__init__.py,sha256=aQWBmjLPrxvaRdqhy_ufdeUzJNDQVaYbqxu1-Iet97M,644
+memoryforge/lcm/compaction/compactor.py,sha256=CflOHezlAe00SSo2oOML0wpwtNwA0C99lms1rc9PWFo,16619
+memoryforge/lcm/compaction/engine.py,sha256=ZP3jHZIO4EogbuA5B-Zvi-XnS0HkLofV2GXXoSVpg90,23124
+memoryforge/lcm/compaction/file_ids.py,sha256=DkZN1f9dImAGgMUttpSQfCiLBJSlTII3tzT8pL4q0xk,8416
+memoryforge/lcm/compaction/pruner.py,sha256=L55fgBxwqirtOLpqdEDCd-G1WLl3pgKA7x5QyMUFiRU,2627
+memoryforge/lcm/compaction/subagent_provider.py,sha256=Wnlsv9-0oarVuQsq9QA4gW_tTCPOioUQqwLV-Wh143U,1775
+memoryforge/lcm/context/__init__.py,sha256=2mGSu_WdO5y0CB27gkpQdxp0beNunZqLPzA6Hg5q7yc,221
+memoryforge/lcm/context/builder.py,sha256=wQknhRPcJZyBRkbtbAcvmMz__2y7bQ-Ao35dB8GjYW8,13466
+memoryforge/lcm/conversation/__init__.py,sha256=q62XKOGzayA0zrCySl5lo60DeTB-RNb-lJpU_U77BHQ,263
+memoryforge/lcm/conversation/store.py,sha256=zpao5yUSB39dNRQIGyzHFfU3phyOa7gY-Kih_VepzLY,9061
+memoryforge/lcm/events/__init__.py,sha256=QlH-WTP0g3MYUgfYMwdGrNSuRJiwBBxXRucDukuqcbY,127
+memoryforge/lcm/events/bus.py,sha256=IO89wrLc3Jm2Dw44EKBH6BpnniwTgEnlwURSCyyes4Y,3262
+memoryforge/lcm/refs/__init__.py,sha256=gGUkwO5OVkWica6Yt1DU81v_zm-LfcpPFtw2K1E6_7I,150
+memoryforge/lcm/refs/hash_ref.py,sha256=eCn_o9zYvzJYQQOxURRE7fTcbfI_qU3vSb0eBtlKB-0,851
+memoryforge/lcm/store/__init__.py,sha256=wRlgi_uFbCRiwe0zrzqSIfUX7UO-EA7IswJSGqnhwek,211
+memoryforge/lcm/store/immutable.py,sha256=t0S9jkY4mUvAWD0dQnF3Of7XSpHjSq5KbBwcQjKeXPg,16627
+memoryforge/lcm/summary/__init__.py,sha256=u5AJ8RAarw_eJx7CxO2ZuPKPB8QVCy7FBpFt1-FbnJc,158
+memoryforge/lcm/summary/dag.py,sha256=lcOEou5jlkBXk-SvQwogws9FhQqNYIWX4NMRbbO9828,12409
+memoryforge/lcm/tokens/__init__.py,sha256=6s5kMZnuQUw2P88f-G_N5FUfs1MORKwKMbOnQH7yC0E,130
+memoryforge/lcm/tokens/estimator.py,sha256=padkvacY6jMXaRceZxr_9XC5OUmvTCmBrndE0EEmzIc,3652
+memoryforge/mcp/__init__.py,sha256=NRaLrCzbDqSpkrqp5UsQCQYWSyg-4Mdg0ACFjMLWGiE,108
+memoryforge/mcp/server.py,sha256=xv-nW46MV8JTi3C07k8oBzg5gRgeHN3l2bfISds2LLQ,19854
+memoryforge/mcp/tools.py,sha256=KWt14u8hP-X5lcJPggYo9pDpSU3C-i6m3RprfmCO0uU,13977
+memoryforge/memory/__init__.py,sha256=Bbnn2CLoIJ3k8XYkHbAwV75Cyc8ilH6V2KOvkY4OUXw,691
+memoryforge/memory/longterm/__init__.py,sha256=lHMzgqVhfMn_WDTpmxqdBwDemon6l8V504uQn8cOl8w,887
+memoryforge/memory/longterm/indexing.py,sha256=0h_QnQkAhjWRTYXo0O6zci0USgrJCtQmisfiEWkpIB0,23388
+memoryforge/memory/longterm/models.py,sha256=olLb6Em2OuiZZt-95Gn_PGl0z7E67wUtfR7v5qflbZM,3201
+memoryforge/memory/longterm/retrieval.py,sha256=RNtjxK1Mb2mtrcn8YlCeYW0o2YhZQZwLOf9A3-UJSZc,18816
+memoryforge/memory/longterm/store.py,sha256=skhnMjQ6kF_Zp38GWhSWkzaazUqJ9lBOEK1pGy65xv8,1698
+memoryforge/memory/longterm/utils.py,sha256=_ddc1wmAslxLnVSXCuMW0rgDoN2qGYKQ9SBbqco1wDY,1193
+memoryforge/rlm/__init__.py,sha256=IXeZIBiNH9YKYCL8EhhNlIQYCuovNbUrF0yEvlZG4l8,260
+memoryforge/rlm/chunking.py,sha256=I7OyUN4pKbTU9r6Yb2sELJtyem83kbmnW6et72pmzH8,20545
+memoryforge/rlm/common.py,sha256=o0ZuL1nFU5mUYIVacDFbfk5ZEWy-5N8QMPV-vItMt-I,1618
+memoryforge/rlm/engine.py,sha256=z8-N2cf60HZYjD6C5YWpobe0JKRMvHsyX6QHpads-rE,1238
+memoryforge/rlm/records.py,sha256=OBEhTyQw7pRaCHLy8mTfVJNlK8--2-lo7T6NHveXNWU,11595
+memoryforge/rlm/runner.py,sha256=GS2fPCuzan7N4wFVmTBXpnTyDLlYGvy-51D6MWm1D_o,29266
+memoryforge/rlm/schema.py,sha256=kZ5wDXHP73DVZZZcd6iL1l0M1xUYM4-jo5CE7Ug2xEI,1713
+memoryforge/rlm/search.py,sha256=aDiO3ZyN0VLxr9yrQpRWBptexB2ZrTxk6BC_1Gbs5Q8,6837
+memoryforge/rlm/storage.py,sha256=th0qbYNBKUXplmEksdU6TgyugWysQL7OGSes5lxkzGQ,3541
+memoryforge/rlm/types.py,sha256=LIagtW7OPXbyneRz9i1IUidBfa8qgCdjYw2ZIYH-V7U,438
+memoryforge/search/__init__.py,sha256=YCXnqOdvNmeDbrfw19xMim3fJR-dI5pdKNTWYNil2CA,433
+memoryforge/search/fts.py,sha256=SMG7WrPP9yyg600-4tnaR8u96Ke3VorZgnd_A4R6sFE,1783
+memoryforge/search/router.py,sha256=Ww56M4HBkbuKFJDdQ5DuVRFD7qIhh6fvA0wNcmsMBm8,893
+memoryforge/search/vector.py,sha256=vEHho0Ry3KDc73kdL5d60FwTf3pDdmEm6rpkRryOxfc,21456
+memfg-6.0.0.dist-info/METADATA,sha256=vS3SI_muzdF9SjQJit2cl7kCxdq48OUiWrvAj9AIlZE,10944
+memfg-6.0.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+memfg-6.0.0.dist-info/entry_points.txt,sha256=ZB-N7ArydAd2c2reSXog0PnrsdSDtNqvtYbKSrPar6U,105
+memfg-6.0.0.dist-info/licenses/LICENSE,sha256=qdAta9Rng7wL1L3wEVDrnewqmiD7gDyoF2OCBynWceQ,1102
+memfg-6.0.0.dist-info/RECORD,,

memfg-6.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

memfg-6.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+memoryforge = memoryforge.cli:main
+memoryforge-mcp = memoryforge.mcp.server:run_server

memfg-6.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MemoryForge Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

memoryforge/__init__.py

@@ -0,0 +1,31 @@
+"""MemoryForge v6.0 - Lossless Context Management for Recursive Language Model.
+
+Recursive Language Model substrate:
+- LCM Pipeline: active conversation context with recursive compaction
+- LTM Pipeline: durable file/conversation knowledge with BM25 and vector recall
+- Search Pipeline: BM25/vector fusion for pass-by-reference context recall
+"""
+
+__version__ = "6.0.0"
+
+from memoryforge._core import BM25Index, ContentHashTable, rrf_fusion
+from memoryforge.agents import create_subagent_runner
+from memoryforge.api import CoreContextBundle, MemoryForge
+from memoryforge.lcm import LCMCompactor, SummaryDAG
+from memoryforge.rlm import RLMEngine
+from memoryforge.search.router import UnifiedQueryRouter
+from memoryforge.search.vector import VectorIndex
+
+__all__ = [
+    "ContentHashTable",
+    "BM25Index",
+    "rrf_fusion",
+    "LCMCompactor",
+    "SummaryDAG",
+    "UnifiedQueryRouter",
+    "VectorIndex",
+    "MemoryForge",
+    "CoreContextBundle",
+    "RLMEngine",
+    "create_subagent_runner",
+]