model-d 0.4.0__py3-none-any.whl

model_d-0.4.0.dist-info/METADATA

@@ -0,0 +1,309 @@
+Metadata-Version: 2.4
+Name: model-d
+Version: 0.4.0
+Summary: A shared workspace memory a team's AI agents ask first and teach back: fewer model requests at the same accuracy.
+Author: Devieswar Kancheti
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://optimal-context-mapping-site.vercel.app
+Project-URL: Source, https://github.com/devkancheti4-design/optimal-context-mapping
+Project-URL: Evidence, https://github.com/devkancheti4-design/optimal-context-mapping/tree/main/evidence
+Project-URL: DOI, https://doi.org/10.5281/zenodo.23289068
+Keywords: ai-agents,coding-agents,claude,mcp,code-search,retrieval,context,tokens
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+License-File: THIRD_PARTY_NOTICES
+License-File: ocm/LIFE_LICENSE
+Requires-Dist: numpy>=2.0
+Requires-Dist: torch>=2.1
+Requires-Dist: transformers>=4.40
+Provides-Extra: claude
+Requires-Dist: anthropic; extra == "claude"
+Provides-Extra: openai
+Requires-Dist: openai; extra == "openai"
+Dynamic: license-file
+
+# Model D (Optimal Context Mapping)
+
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.23289068.svg)](https://doi.org/10.5281/zenodo.23289068)
+[![License: Apache-2.0](https://img.shields.io/badge/License-Apache%202.0-blue)](LICENSE)
+
+**AI on your codebase, with a bill that flattens as your team works.**
+
+Every AI coding agent on a team pays to search the same code again, and each search step is a paid model request.
+Model D is a deterministic kit fused with the Claude API you already use:
+- The kit maps your code once, on your machines, into 1,024-bit fingerprints ranked by small laws.
+- Before each request, it decides where to look, at zero tokens.
+- Claude reads what the kit already knows and explores only what is new.
+- Every exploration teaches the kit, so the next engineer's question costs less.
+
+```bash
+uv tool install git+https://github.com/devkancheti4-design/optimal-context-mapping   # PyPI: uv tool install model-d
+modeld install                                       # wires it into Claude Code, Codex, Gemini CLI and Kiro
+modeld build . --cache ~/.cache/modeld/embed.sqlite  # maps this repository; rebuilds embed only what changed
+```
+
+## Where it pays
+
+| work | vs the same agent alone | measured on |
+|---|---|---|
+| **A team's real year of fixes on one codebase** | **2.09x cheaper, the same work (252 vs 253 right); 1.88x → 2.57x as the year went on** | Django's 288 fixes from 2022, in order ([evidence/team-year](evidence/team-year)) |
+| A team asking about its own repository | 2.3–2.8x cheaper, same accuracy | a company app, 5 roles, 3 runs |
+| The same question again, in other words | 5–10x cheaper | 228-question stream; Gemini, 3 runs |
+| Brand-new, scattered bugs | about 1.35x | 114 Django bugs, 3 runs |
+| Finding the fixed file, offline | top-5 176 vs Graphify's 131, of 285 | SWE-bench Lite, 12 full repositories |
+| Code review | small, about 1.3x at most: reviewers search about 3 times per PR | SWR-Bench pilot, partial ([evidence/swr-pilot](evidence/swr-pilot)) |
+
+Every plan was hashed before it ran, and `python evidence/verify.py` recomputes every number from the raw rows.
+
+## Pricing
+- **Open source, $0:** the whole kit under Apache-2.0, self-hosted, for one developer or a team server.
+- **Team, $49 per engineer per month:** we set up your team server, send a monthly savings report from your own
+  logs, and give priority fixes and a private support channel.
+- **Enterprise, by contract:** air-gapped installs, rollout across many repositories, and a guaranteed response time.
+
+Model D adds no model cost of its own. It cuts the API bill you already pay. For a team server, Docker and offline
+installs, see [DEPLOY.md](DEPLOY.md). To get the most out of it, see [GUIDE.md](GUIDE.md).
+
+## Why it works: work on a codebase isn't novel
+
+Ten years of Django, 5,333 real fixes, touched only 650 files. After the first thousand fixes, 96–99% landed in a
+file already fixed before. The files a team touches grow like the square root of its work (Heaps' law, fitted:
+D(n) = 12·n^0.48). So the search for where to look should be paid once. The learning law says how much that
+saves: S = A / ((1 − ν)·E + ν·K), where ν is the share of new work, E one learned read ($0.0004) and K a first
+exploration with the kit. On Django's 2022 it forecast each quarter's saving from the earlier ones within 14%.
+
+## How to use it
+
+### 1. Install (Python 3.10+)
+
+```bash
+uv tool install model-d     # or pipx install model-d, or pip install model-d; from a clone: pip install -e .
+```
+
+This installs the `modeld` command (and `modeld-mcp`), with numpy, torch and transformers. `python -m ocm` runs
+the same commands. The embedding model (bge-base-en-v1.5) downloads once on the first build;
+after that you can set `OCM_OFFLINE=1`.
+
+### 2. Scan your repositories into a workspace
+
+```bash
+modeld build ~/code/our-api ~/code/our-web ~/code/our-docs --out ~/ocm-workspace
+```
+
+- **What gets kept:** every code and doc file under the folders you pass. Code is cut into blocks and docs into
+  sentences, and each becomes a 1,024-bit fingerprint, computed on your machine.
+- **What is skipped:** `.env` files, keys, certificates, credential files, lockfiles, dependency and build folders, and
+  anything over 512 KB.
+- **Also indexed:** build files with no extension (`Dockerfile`, `Makefile` and the like), `.conf`, `.mjml`, `.vscode`.
+  Doc sentences keep their line numbers.
+- **Device:** a GPU is used automatically when present (CUDA, or Apple silicon); `--device cpu` forces the CPU.
+
+**Rebuilding after code changes?** Carry what the team taught into the new workspace:
+
+```bash
+modeld build ~/code/our-api ~/code/our-web --out ~/ocm-workspace-new --carry ~/ocm-workspace
+```
+
+The workspace keeps an exact memory of what was taught (`taught.life.json`, a Life from living-fused). On a carry,
+each taught question is found in the new code by its exact line and its vector is taught again; an entry whose line
+is gone abstains instead of guessing.
+
+### 3. Serve it to the team
+
+```bash
+modeld serve ~/ocm-workspace --port 7700                  # just you
+modeld serve ~/ocm-workspace --port 7700 --host 0.0.0.0   # your team, on your network
+```
+
+Run one server per team; everyone's agents share it. Every call is logged to `<workspace>/calls.jsonl`.
+
+For a bug report, or any question whose answer is in code, ask with `"scope": "code"`. Documentation (`.md`, `.rst`,
+`.txt` and the like) then stays out of the ranking. In a full repository, release notes and reference pages can
+otherwise fill much of the readout. `OCM_SCOPE=code` makes it the server's default; the MCP tools take `scope` too.
+
+### 4. Put it in your agents' loop
+
+**One command per agent.** `ocm init` writes the right config into a repository. It merges into existing files, keeps
+your other settings, and is safe to run again:
+
+```bash
+modeld init claude ~/code/our-api --url http://ws.internal:7700    # Claude Code: two hooks + a CLAUDE.md note
+modeld init kiro   ~/code/our-api --url http://ws.internal:7700    # Kiro: .kiro/settings/mcp.json + .kiro/steering/ocm.md
+modeld init codex  ~/code/our-api --url http://ws.internal:7700    # OpenAI Codex: .codex/config.toml + AGENTS.md
+modeld init gemini ~/code/our-api --url http://ws.internal:7700    # Gemini CLI: .gemini/settings.json + GEMINI.md
+modeld init all    ~/code/our-api --url http://ws.internal:7700    # all four
+```
+
+What each writes, by hand, follows.
+
+**Claude Code (recommended): two hooks, nothing for the model to call.** Add this to the project's
+`.claude/settings.json`, and point `OCM_URL` at the team's server if it is not local:
+
+```json
+{"env": {"OCM_URL": "http://127.0.0.1:7700"},
+ "hooks": {
+  "UserPromptSubmit": [{"hooks": [{"type": "command", "command": "modeld hook prompt"}]}],
+  "Stop": [{"hooks": [{"type": "command", "command": "modeld hook stop"}]}]
+}}
+```
+
+- **Before each request**, the prompt hook adds the code its laws rank for the question: the code a taught question's
+  vector points to (and then the router's next readout), or the nearest code and docs by meaning and keyword.
+- **The model** answers from them when they answer the question, searches when they do not, and ends its reply with
+  `TEACH: <question> | <path>:<line>`, the line its answer is on.
+- **After the reply**, the stop hook teaches those lines on your machine, at no model cost: each question's vector
+  becomes a cue on the code holding that line. No answer text is stored.
+- **Between tasks**, run `/clear`. The next task starts from the workspace, not from the old transcript.
+
+**Cursor and other MCP clients: as tools.** Add this to `.mcp.json` (Cursor: `.cursor/mcp.json`), and add
+`pilot/AGENT_INSTRUCTIONS.md` to the agent's rules:
+
+```json
+{"mcpServers": {"ocm": {"command": "modeld", "args": ["mcp"], "env": {"OCM_URL": "http://127.0.0.1:7700"}}}}
+```
+
+This costs a round trip per question, and in our team proof it did not save requests on its own (section 6). Use the
+hooks where you can.
+
+**Kiro, OpenAI Codex, Gemini CLI: as MCP tools.** `ocm init kiro|codex|gemini` registers the same four tools in each
+tool's own MCP config, and puts the instructions where that agent reads them (`.kiro/steering/`, `AGENTS.md`,
+`GEMINI.md`).
+
+**Any other agent loop:** call `ocm.loop.prefetch(question)` before the model call, put the result in the prompt, and
+call `ocm.loop.teach_from_reply(reply)` after it.
+
+### The hybrid: the kit decides, the model reads or teaches
+
+`ocm hybrid` runs a question through the hybrid. The kit's laws make every decision, at no model cost, and a model is
+called only for one of two jobs:
+
+- **Read:** the question is near one the kit was taught. The model reads the code the kit chose, once and with no tools,
+  and answers. If that code does not hold the answer, it says so and the question goes on to be taught.
+- **Teach:** the question is new. The model explores (search, read, list on the team's workspace) just enough to find
+  the one line the answer is on. The kit learns that line, so the next question like it costs one read.
+
+```bash
+export OCM_URL=http://ws.internal:7700
+modeld hybrid "What stops a deploy with placeholder secrets?" --provider claude   # ANTHROPIC_API_KEY
+modeld hybrid "..." --provider openai                                             # OPENAI_API_KEY (pip install openai)
+modeld hybrid "..." --provider gemini                                             # GEMINI_API_KEY, or a Vertex project
+```
+
+| Provider | Reads with | Teaches with | Keys |
+|---|---|---|---|
+| `claude` (Anthropic SDK) | Claude Haiku 5.5 | Claude Sonnet 5.5 | `ANTHROPIC_API_KEY`, or `OCM_VERTEX_PROJECT` for Claude on Vertex AI |
+| `openai` (OpenAI SDK) | `--reader`, default `gpt-5.6-terra` | `--teacher`, same default | `OPENAI_API_KEY` |
+| `gemini` (REST) | gemini-2.5-flash | gemini-2.5-flash | `GEMINI_API_KEY`, or `OCM_VERTEX_PROJECT` |
+
+In code: `from ocm.hybrid import run, provider, Workspace`, then
+`run(question, provider("claude"), Workspace("http://ws.internal:7700"))`. It returns the path taken (`read` or
+`teach`), the answer, the line taught, and the number of model requests. Measured so far (gemini-2.5-flash): one read
+was right on 90/90 taught questions, and on 30/30 with Claude Haiku 5.5. The Gemini adapter has been run live end to
+end. The Claude and OpenAI adapters are covered by the offline tests, but have not yet been run against their live
+APIs.
+
+### 5. Measure what it saves you
+
+```bash
+modeld calc --repeat 0.5 --deep 0.3 --questions-per-month 16800   # an estimate for your mix
+modeld measure compare ~/before-transcripts ~/after-transcripts    # the real thing, from your agents' transcripts
+```
+
+`pilot/PILOT.md` is a two-to-four-week plan for a fair before-and-after; fix it before you start
+(`pilot/PREREGISTRATION.md`). Run the kit's tests with `python -m pytest -q tests`.
+
+## Big repositories
+
+What we measured with this kit on a MacBook (Apple silicon; its GPU was picked automatically):
+
+| | measured |
+|---|---|
+| Scanning | 3,898 units in 13 s; transformers (10.8M tokens, 2,347 files) is 183,830 units and took 28 minutes |
+| Storage | 128 bytes of fingerprint per unit: 183,875 units take 23.5 MB |
+| Readout per request | 0.07 s over 183,875 units (the bit comparison itself takes 2.5 ms) |
+| Results at size | live, this kit: 1.71x fewer requests over 10.8M tokens against 1.25x over 148k; earlier research harness: 9.2x on repeats over 10.8M, 6.1x over 7 codebases (7M tokens) |
+
+- **Scope it.** Build one workspace over the repositories a team actually works in; one workspace over everything beat
+  one per codebase in our test.
+- **Recall falls as size grows.** First-time questions find their answer less often in the first readout. Repeated
+  questions, drawn by a taught question's vector, hold up.
+- **Rebuild after large code changes,** with `--carry` to bring what was taught along.
+
+## How it works
+
+The workspace is a CMLM: vectors and laws, not a store of text.
+- **The vector law** ranks every unit by bits shared with the question: through the vectors of questions taught on
+  it, and through its own text.
+- **The router law** picks which readout to send from eight free checks: the code a taught question's vector points
+  to, the 10 nearest by meaning, by keyword, or both. When the first readout is the taught one, the hook also sends
+  the router's next readout (its ADVANCE), so a near miss costs no search.
+- **The learned law** reorders the nearest by meaning once it beats the vector order on your team's own questions.
+
+**Teaching trains the CMLM on your machine, at no model cost.** A TEACH line names a question and the line its answer
+is on. The question's vector becomes a cue on the unit holding that line, so a later question near it in meaning is
+drawn to that code (vector generalisation), and it is an example for the learned law. Nothing the model wrote is
+stored, and what the model gets back is always the code itself, with its path and line.
+
+It is ranking math. The readout is ranked, not verified, so the model is told to use it only if it answers the
+question.
+
+## Privacy
+
+Everything runs on your machines. Only the embedding model is downloaded, once; your code and questions never leave
+your network.
+
+## Limits, stated plainly
+
+- **Repetition drives savings.** One-off questions save less, and short sessions that keep their own context gain
+  little.
+- **Clear the session between tasks.** In Claude Code the facts the hook adds stay in the transcript and are re-read
+  on every later request:
+  - At 100 questions in one session, that cost 1.25x more than no CMLM (section 10).
+  - The same 100 questions in fresh 10-question sessions cost 1.31x less than one long session, at the same accuracy
+    (section 11). The CMLM keeps what was taught.
+  - If you must keep one long session, `OCM_COMPACT=1` cuts each readout to its top 3 items. That cut the pile-up
+    1.19x, but it still cost 1.05x more than no CMLM.
+- **Repeats still cost a read today.** The TEACH rule asks for the exact line, and agents read the file to confirm it
+  even when the readout held the answer. Only 6 of 100 questions were answered with no search (section 12).
+- **Deep dives** that chain across many files save little today: a taught question points at one line, not a whole
+  trail.
+- **Billed input falls less than requests**, because readouts add reading.
+- **The learned law rarely switches on for code** in our tests.
+- **Taught vectors are append-only.** A rebuild carries them only with `--carry`: to the same line, or to the same line
+  reformatted (whitespace ignored), and `--prune-after N` drops a lesson whose line has been gone for N rebuilds in a
+  row. In our live test a carry over 400 commits kept 40 of 47 entries, but it did not save requests (section 13).
+- **The tests are narrow:** open-source code and one client app, with Claude agents and judges. Your codebase is the
+  real test.
+
+## Public benchmarks
+
+Model D's retrieval is compared with Graphify on LOCOMO and on finding the file a fix changed. On 285 SWE-bench Lite
+issues in 12 full repositories, with the code scope and the test plan fixed before it ran, Model D listed the fixed file
+in its first five 176 times (issue titles) and 183 times (title + 400 characters), against 131 and 122 for Graphify
+0.9.87, with about 2.4x fewer tokens (`evidence/swe-bench-lite/`). The study is reproducible, and the Claude Code
+plugin is in the same repository: https://github.com/devkancheti4-design/model-d-graphify
+
+## Licence
+
+Apache License 2.0 (see `LICENSE` and `NOTICE`).
+- `ocm/life.py` is also available under the MIT licence (`ocm/LIFE_LICENSE`).
+- Third-party components are listed in `THIRD_PARTY_NOTICES`.
+
+## Cite
+
+If you use this work, please cite it:
+
+> Kancheti, D. (2026). *Optimal Context Mapping (Model D): a shared, learning retrieval layer for AI coding agents*
+> (Version 0.2.1) [Computer software]. Zenodo. https://doi.org/10.5281/zenodo.23289068
+
+`CITATION.cff` has the same citation, and the DOI for all versions is 10.5281/zenodo.23289067.
+
+Copyright 2026 Devieswar Kancheti.

model_d-0.4.0.dist-info/RECORD

@@ -0,0 +1,39 @@
+model_d-0.4.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+model_d-0.4.0.dist-info/licenses/NOTICE,sha256=_eQyzI7mxsZYfMllgPLEhFDwunVG40QTTVzN9JnTIHU,305
+model_d-0.4.0.dist-info/licenses/THIRD_PARTY_NOTICES,sha256=dD1c8sIATxdWDJE7F9noo3Uio9RAplCitLGLm7lo74o,598
+model_d-0.4.0.dist-info/licenses/ocm/LIFE_LICENSE,sha256=2vGTL1OyhQdQUh8HMTLWm6BjZtPd6QY68MRnycVHp8I,1076
+ocm/LIFE_LICENSE,sha256=2vGTL1OyhQdQUh8HMTLWm6BjZtPd6QY68MRnycVHp8I,1076
+ocm/__init__.py,sha256=7icOYZ7d_Y7YbYPVVW4EMH77RqnMpKW0ZUv1TWnoVHA,127
+ocm/__main__.py,sha256=ZsUVsGC0Z7GgYFuOYKK-AnMeGoBvSZ8Z0z5EPHRyj-E,506
+ocm/build.py,sha256=8llDPYO270JZMKmRgMCCT5fRyfgZBsz_jH_LQEA3dUY,4970
+ocm/calc.py,sha256=QYoaYkyA0Fh9gEcREQyAeygke9QfU62_AJoSKu2rxCU,3512
+ocm/cli.py,sha256=9sMJ9Qg9bBK0qf60wVC1bSjAlHBbKyc16pdhgbhS2zI,8369
+ocm/embed_cache.py,sha256=hQWGFajvemh4UKfQpjb42tO4rbdxCYQFTlJnByMpS2s,2367
+ocm/hybrid.py,sha256=FGR-1mWyQgEpp7KHLclWrHH7icMDpLF2jW5Z3McMIWU,5860
+ocm/init.py,sha256=VPm5LjSDxx0rSoKINWl8TTqz17KLsSoxSg3pdivPlgc,6708
+ocm/install.py,sha256=_b2dzNzbG4bPbb2hrWJurOuE0uM2EtOZUFA1utd6WDk,4383
+ocm/life.py,sha256=vY2Ywuxfbv9Q6JAYbJIKj_5DF_0kssqvGCp3yx7fwBA,12286
+ocm/loop.py,sha256=YEx9A68XHrmxTiVft7Kg0RTnRLR2EIJuK3SGeUDW_Os,5807
+ocm/mcp.py,sha256=OpccTQC3R0i3DMT6qyby66DD0GAyQ0ExwA-ETQv5RDE,5793
+ocm/measure.py,sha256=lPyDs5Z5VGKo3Z3X69se0J1l6CAOCMwbXIAuso5Xs_o,3868
+ocm/server.py,sha256=04dXF1Rl5w2OAduIwXPCD_y2xWbXPoOA-83LPSG1pdA,17232
+ocm/units.py,sha256=7V4CppCPSNDZPuVjS8gQZWBQddYTzYftkPvJVmG9gPM,5293
+ocm/cmlm_vector/__init__.py,sha256=OoR4SRXV2Ty1tHaWT54Rl4Mpk_-W_YVkEFUNhn5hcUI,209
+ocm/cmlm_vector/chunk.py,sha256=Ub5ssiOzsmXawy6S6-JhU7Wd_OgXhfOeCnfbmnP35PQ,1982
+ocm/cmlm_vector/cli.py,sha256=_6L_BcWwGQuUdM8r-0FpUCi-a7kTbajLYf1UnHMmPag,4331
+ocm/cmlm_vector/embed.py,sha256=gyKt3yyXAbUBz6Ug8A1QV7fqTymCNB7xkAh_lVFOl7E,3221
+ocm/cmlm_vector/lawsearch.py,sha256=FdQGc3DpgXjUJPHHWTIw3UTaR9T-79QLRqwEQFG0DiI,7802
+ocm/cmlm_vector/memory.py,sha256=qx3F98VWvlXcenlednNZGE4Wd85d57vrWNVWsMj0QGI,21655
+ocm/data/pools.json,sha256=E0xt3l1vBHw0m4MnKWLDVWhikjosEGXiGWtxWPwV82U,3686
+ocm/providers/__init__.py,sha256=FinIDGSHf4GoK1N0-NRVi89tvGB7DWU3tQ7a-XsoC3Y,195
+ocm/providers/claude_api.py,sha256=9fQmtWXZd6Dca6tajbdQLUfOLBiIwsctlXMVln2hTJA,2611
+ocm/providers/gemini_api.py,sha256=tQ-BwPiCeFYqYseWmYsoKVHTr5r95pdCN3GXMPdquEs,4555
+ocm/providers/openai_api.py,sha256=XKYALSEd-oVq8spAl0VH0cFQe5IsTRlfYqZ_J2kYZMs,2204
+ocm/router/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ocm/router/lanes.py,sha256=aO1SFdTADX45LuYesvCR86xkiDV2flX4km-D8WVBw3Q,7314
+ocm/router/router.py,sha256=k6Q1M2FhBGGfIQBs0L0MrjUA6oNnFOaiy5BLsgb0iPk,3914
+model_d-0.4.0.dist-info/METADATA,sha256=inYNX841RquXO8uOyXwYafNGi0-kZG91ovnPGlobl8o,17421
+model_d-0.4.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+model_d-0.4.0.dist-info/entry_points.txt,sha256=fU9-bJO9jbgvnKmfaOZBP7U2LB-DHqeKhoHgoWSJF-w,90
+model_d-0.4.0.dist-info/top_level.txt,sha256=JGU4u4TV6pTRvXJ2yPQin4IB1P8OVZ-OsoF0Sb7muYw,4
+model_d-0.4.0.dist-info/RECORD,,

model_d-0.4.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

model_d-0.4.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+modeld = ocm.cli:main
+modeld-mcp = ocm.mcp:main
+ocm = ocm.__main__:main

model_d-0.4.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

model_d-0.4.0.dist-info/licenses/NOTICE

@@ -0,0 +1,7 @@
+Optimal Context Mapping (Model D)
+Copyright 2026 Devieswar Kancheti
+
+Licensed under the Apache License, Version 2.0 (see LICENSE).
+
+ocm/life.py (the Life) is also available under the MIT licence; see ocm/LIFE_LICENSE.
+The third-party components it installs or downloads are listed in THIRD_PARTY_NOTICES.

model_d-0.4.0.dist-info/licenses/THIRD_PARTY_NOTICES

@@ -0,0 +1,11 @@
+Third-party components
+
+Optimal Context Mapping installs and uses these open-source components, each under its own licence. None of them is
+modified or bundled in this package; pip installs them from their usual sources.
+
+- NumPy: BSD 3-Clause licence.
+- PyTorch: BSD 3-Clause licence.
+- Hugging Face transformers, tokenizers, safetensors and huggingface-hub: Apache License 2.0.
+- BAAI/bge-base-en-v1.5 (the embedding model, downloaded once from Hugging Face on the first build): MIT licence.
+
+Optional, only if you use the matching provider in `ocm hybrid`: anthropic (MIT), openai (Apache 2.0).

model_d-0.4.0.dist-info/licenses/ocm/LIFE_LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 devkancheti4-design
+
+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.

model_d-0.4.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ocm

ocm/LIFE_LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 devkancheti4-design
+
+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.

ocm/__init__.py

@@ -0,0 +1,2 @@
+"""Optimal context mapping: a shared workspace memory your team's AI agents ask first and teach back."""
+__version__ = "0.4.0"

ocm/__main__.py

@@ -0,0 +1,14 @@
+"""python -m ocm <build | serve | hook | mcp | init | hybrid | measure | calc> ...  (see README.md)"""
+import sys
+
+
+def main():
+    cmds = {"build": "build", "serve": "server", "hook": "loop", "mcp": "mcp", "init": "init", "hybrid": "hybrid", "measure": "measure", "calc": "calc"}
+    if len(sys.argv) < 2 or sys.argv[1] not in cmds:
+        print(__doc__); sys.exit(2)
+    import importlib
+    importlib.import_module(f"ocm.{cmds[sys.argv[1]]}").main(sys.argv[2:])
+
+
+if __name__ == "__main__":
+    main()