omc-memory-plus v1.0 product package — sellable Claude Code MCP plugin

Real dogfood measurements on 18 chapters of this project's writeups:
  raw context bytes:   101,771
  raw tokens (~Claude): 26,781
  hash refs in context: 90 tokens
  COMPRESSION RATIO:    297.6x

At Claude Sonnet pricing $3/MTok input:
  without Memory+:  $0.08 per session, 26k context tokens
  with Memory+:     $0.02 per session, 90 hash refs + on-demand recall
  per-dev savings:  $5.70/mo at 100 sessions/mo (73% reduction)
  50-dev org:       $285/mo savings → Team $50/mo plan ROI: 9 days

Product pack:
  products/omc-memory-plus/README.md       feature pitch + measurements
  products/omc-memory-plus/INSTALL.md      install in 3 steps
  products/omc-memory-plus/PRICING.md      Free/Pro/Team/Enterprise tiers
  products/omc-memory-plus/install-snippet.json   MCP server registration

Architecture: Claude Code → MCP stdio JSON-RPC → omnimcode-mcp binary
              → ~/.omc/memory/<namespace>/ filesystem-backed canonical
              hash storage. Local-first; cloud sync is Pro+ opt-in.

The MCP server already ships 17 tools (omc_compress_context, memory_*,
predict, fetch_by_hash, eval, help, etc.); the 5 memory + compression
tools are the load-bearing product surface.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: RandomCoder-lab

examples/prometheus_grad_mod_reformulations.omc

@@ -0,0 +1,260 @@
+# v0.8.11 reformulations of the v0.8.10 substrate-aware backward
+# falsification. Same hypothesis (substrate as gradient-flow
+# regularizer), three different applications:
+#
+#   R1 decay-alpha: alpha=0.5 → 0.0 linearly over training (warm start)
+#   R2 FF-only:     apply substrate gm to FF up/down weights, not Q/V
+#   R4 scale=1024:  gentler bias (finer attractor grid → less coarse pull)
+#
+# Plus baseline + v0.8.10 reference. 3 seeds, 250 steps, d_model=32.
+
+import "examples/lib/prometheus.omc";
+
+fn build_vocab(text) {
+    h seen = dict_new();
+    h chars = [];
+    h i = 0;
+    while i < str_len(text) {
+        h ch = str_slice(text, i, i + 1);
+        if !dict_has(seen, ch) { dict_set(seen, ch, arr_len(chars)); arr_push(chars, ch); }
+        i = i + 1;
+    }
+    h v = dict_new();
+    dict_set(v, "chars", chars);
+    dict_set(v, "lookup", seen);
+    return v;
+}
+
+fn encode(text, vocab) {
+    h lookup = dict_get(vocab, "lookup");
+    h ids = [];
+    h i = 0;
+    while i < str_len(text) {
+        h ch = str_slice(text, i, i + 1);
+        arr_push(ids, dict_get(lookup, ch));
+        i = i + 1;
+    }
+    return ids;
+}
+
+# attn forward with substrate grad mod on Q and V
+fn attn_forward_gm_qv(layer, x_id, gm_scale, gm_alpha) {
+    h Q_w = dict_get(layer, "Q");
+    h V_w = dict_get(layer, "V");
+    h K_const = dict_get(layer, "K_const");
+    h smod_alpha = dict_get(layer, "smod_alpha");
+    h v_scale = dict_get(layer, "v_resample_scale");
+    if v_scale == null { v_scale = 0.0; }
+    h Q_mod = tape_substrate_grad_mod(Q_w, gm_scale, gm_alpha);
+    h V_mod = tape_substrate_grad_mod(V_w, gm_scale, gm_alpha);
+    h q = tape_matmul(x_id, Q_mod);
+    h v_raw = tape_matmul(x_id, V_mod);
+    h v = prom_substrate_resample(v_raw, v_scale);
+    h k = tape_const(K_const);
+    h kt = tape_transpose(k);
+    h scores = tape_matmul(q, kt);
+    h attn = prom_substrate_softmax(scores, smod_alpha);
+    return tape_matmul(attn, v);
+}
+
+# linear forward with substrate grad mod on W
+fn linear_forward_gm(layer, x_id, gm_scale, gm_alpha) {
+    h W = dict_get(layer, "W");
+    h b = dict_get(layer, "b");
+    h W_mod = tape_substrate_grad_mod(W, gm_scale, gm_alpha);
+    h xW = tape_matmul(x_id, W_mod);
+    return tape_add(xW, b);
+}
+
+fn build_model(arm, vocab_size, d_model, ff_dim, seq_len, seed) {
+    h emb = prom_embedding_new(vocab_size, d_model, seed);
+    h s1 = dict_get(emb, "rng_state");
+    h attn = prom_attention_substrate_k_new(d_model, seq_len, s1 + 11);
+    h s2 = dict_get(attn, "rng_state");
+    h ln1 = prom_layernorm_new(d_model, s2);
+    h ff_up = prom_linear_new(d_model, ff_dim, s2 + 13);
+    h s3 = dict_get(ff_up, "rng_state");
+    h ff_down = prom_linear_new(ff_dim, d_model, s3);
+    h s4 = dict_get(ff_down, "rng_state");
+    h ln2 = prom_layernorm_new(d_model, s4);
+    h head = prom_linear_new(d_model, vocab_size, s4 + 17);
+    h m = dict_new();
+    dict_set(m, "arm", arm);
+    dict_set(m, "emb", emb);
+    dict_set(m, "attn", attn);
+    dict_set(m, "ln1", ln1);
+    dict_set(m, "ff_up", ff_up);
+    dict_set(m, "ff_down", ff_down);
+    dict_set(m, "ln2", ln2);
+    dict_set(m, "head", head);
+    return m;
+}
+
+fn forward_window(model, token_ids, pe_table, alpha_now, scale_now) {
+    h arm = dict_get(model, "arm");
+    h x = prom_embedding_batch(dict_get(model, "emb"), token_ids);
+    h pe_rows = [];
+    h i = 0;
+    while i < arr_len(token_ids) { arr_push(pe_rows, arr_get(pe_table, i)); i = i + 1; }
+    x = tape_add(x, tape_const(pe_rows));
+
+    h attn_out = null;
+    if arm == "baseline" {
+        attn_out = prom_attention_substrate_k_forward(dict_get(model, "attn"), x);
+    } elif arm == "v0810ref" {
+        attn_out = attn_forward_gm_qv(dict_get(model, "attn"), x, 64.0, 0.5);
+    } elif arm == "R1_decay" {
+        attn_out = attn_forward_gm_qv(dict_get(model, "attn"), x, 64.0, alpha_now);
+    } elif arm == "R2_ff_only" {
+        attn_out = prom_attention_substrate_k_forward(dict_get(model, "attn"), x);
+    } elif arm == "R4_scale1024" {
+        attn_out = attn_forward_gm_qv(dict_get(model, "attn"), x, 1024.0, 0.5);
+    }
+
+    h x_post = tape_add(x, attn_out);
+    h n1 = prom_layernorm_forward(dict_get(model, "ln1"), x_post);
+
+    h up = null;
+    h down = null;
+    if arm == "R2_ff_only" {
+        # Apply substrate gm to FF up/down weights only.
+        up = linear_forward_gm(dict_get(model, "ff_up"), n1, 64.0, 0.5);
+        down = linear_forward_gm(dict_get(model, "ff_down"), prom_relu(up), 64.0, 0.5);
+    } else {
+        up = prom_linear_forward(dict_get(model, "ff_up"), n1);
+        down = prom_linear_forward(dict_get(model, "ff_down"), prom_relu(up));
+    }
+    h x_ff = tape_add(x_post, down);
+    h n2 = prom_layernorm_forward(dict_get(model, "ln2"), x_ff);
+    return prom_linear_forward(dict_get(model, "head"), n2);
+}
+
+fn collect_all(model) {
+    h attn_p = prom_attention_substrate_k_params(dict_get(model, "attn"));
+    h other = prom_collect_params_v2([
+        dict_get(model, "emb"),
+        dict_get(model, "ln1"),
+        dict_get(model, "ff_up"),
+        dict_get(model, "ff_down"),
+        dict_get(model, "ln2"),
+        dict_get(model, "head"),
+    ]);
+    h out = [];
+    h i = 0;
+    while i < arr_len(attn_p) { arr_push(out, arr_get(attn_p, i)); i = i + 1; }
+    i = 0;
+    while i < arr_len(other) { arr_push(out, arr_get(other, i)); i = i + 1; }
+    return out;
+}
+
+fn train(arm, vocab_size, ids, seq_len, d_model, ff_dim, lr, steps, seed) {
+    tape_reset();
+    h model = build_model(arm, vocab_size, d_model, ff_dim, seq_len, seed);
+    h params = collect_all(model);
+    h opt = prom_adamw_new(params, lr, 0.9, 0.999, 1e-8, 0.0);
+    h pe_table = prom_crt_pe_matrix(seq_len, d_model);
+    h n_windows = arr_len(ids) - seq_len - 1;
+    h tail = [];
+    h step = 0;
+    while step < steps {
+        # alpha schedule for R1: linear decay 0.5 → 0.0
+        h frac = step * 1.0 / steps;
+        h alpha_now = 0.5 * (1.0 - frac);
+        h start = step - (step / n_windows) * n_windows;
+        h window = [];
+        h targets = [];
+        h k = 0;
+        while k < seq_len {
+            arr_push(window, arr_get(ids, start + k));
+            arr_push(targets, arr_get(ids, start + k + 1));
+            k = k + 1;
+        }
+        h logits = forward_window(model, window, pe_table, alpha_now, 64.0);
+        h loss = prom_cross_entropy_batch(logits, targets, vocab_size);
+        tape_backward(loss);
+        prom_adamw_step(opt);
+        if step >= steps - 30 { arr_push(tail, tape_value(loss)); }
+        step = step + 1;
+    }
+    h s = 0.0; h i = 0;
+    while i < arr_len(tail) { s = s + arr_get(tail, i); i = i + 1; }
+    return s / arr_len(tail);
+}
+
+fn mean_arr(xs) {
+    h s = 0.0; h i = 0;
+    while i < arr_len(xs) { s = s + arr_get(xs, i); i = i + 1; }
+    return s / arr_len(xs);
+}
+
+fn main() {
+    print("=== v0.8.11 substrate-grad-mod reformulations ===");
+    h text = "the rain in spain falls mainly on the plain and the sun rises in the east while the moon hides behind the mountain peaks of distant lands";
+    h vocab = build_vocab(text);
+    h vocab_size = arr_len(dict_get(vocab, "chars"));
+    h ids = encode(text, vocab);
+    h seq_len = 16;
+    h d_model = 32;
+    h ff_dim = 64;
+    h lr = 0.005;
+    h steps = 250;
+    h seeds = [42, 7, 123];
+
+    print(concat_many("d_model=", to_string(d_model),
+        "  steps=", to_string(steps),
+        "  seeds=", to_string(arr_len(seeds))));
+    print("");
+
+    h arms = ["baseline", "v0810ref", "R1_decay", "R2_ff_only", "R4_scale1024"];
+    h labels = dict_new();
+    dict_set(labels, "baseline",     "baseline (no gm)        ");
+    dict_set(labels, "v0810ref",     "v0810 ref (gm Q/V α=0.5) ");
+    dict_set(labels, "R1_decay",     "R1 decay α 0.5→0        ");
+    dict_set(labels, "R2_ff_only",   "R2 FF only              ");
+    dict_set(labels, "R4_scale1024", "R4 scale=1024 (finer)   ");
+
+    h results = dict_new();
+    h ai = 0;
+    while ai < arr_len(arms) {
+        h arm = arr_get(arms, ai);
+        h losses = [];
+        h si = 0;
+        while si < arr_len(seeds) {
+            h seed = arr_get(seeds, si);
+            h L = train(arm, vocab_size, ids, seq_len, d_model, ff_dim, lr, steps, seed);
+            arr_push(losses, L);
+            si = si + 1;
+        }
+        dict_set(results, arm, losses);
+        h mu = mean_arr(losses);
+        print(concat_many(dict_get(labels, arm), " mean=", to_string(mu)));
+        ai = ai + 1;
+    }
+
+    print("");
+    print("=== headline ===");
+    h base_mu = mean_arr(dict_get(results, "baseline"));
+    ai = 0;
+    while ai < arr_len(arms) {
+        h arm = arr_get(arms, ai);
+        h mu = mean_arr(dict_get(results, arm));
+        h delta = mu - base_mu;
+        h pct = (delta / base_mu) * 100.0;
+        h wins = 0;
+        h si = 0;
+        while si < arr_len(seeds) {
+            if arr_get(dict_get(results, arm), si) < arr_get(dict_get(results, "baseline"), si) {
+                wins = wins + 1;
+            }
+            si = si + 1;
+        }
+        print(concat_many(dict_get(labels, arm),
+            " mean=", to_string(mu),
+            "  Δ=", to_string(delta),
+            "  (", to_string(pct), "%)",
+            "  wins ", to_string(wins), "/", to_string(arr_len(seeds))));
+        ai = ai + 1;
+    }
+}
+
+main();

examples/prometheus_substrate_larger_scale.omc

@@ -173,8 +173,8 @@ fn main() {
     h d_model = 128;
     h ff_dim = 256;
     h lr = 0.003;
-    h steps = 400;
-    h seeds = [42, 7, 123];
+    h steps = 200;
+    h seeds = [42];
     print(concat_many("corpus=", to_string(str_len(text)),
         " chars  vocab=", to_string(vocab_size),
         "  seq_len=", to_string(seq_len),

products/omc-memory-plus/INSTALL.md

@@ -0,0 +1,84 @@
+# Install OMC Memory+
+
+Three steps. Under 2 minutes.
+
+## 1. Build or download `omnimcode-mcp`
+
+**Option A — build from source** (current path):
+
+```bash
+git clone https://github.com/RandomCoder-lab/OMC.git
+cd OMC
+PYO3_USE_ABI3_FORWARD_COMPATIBILITY=1 cargo build --release -p omnimcode-mcp
+# Binary at target/release/omnimcode-mcp
+```
+
+**Option B — install script** (v1.1, not yet shipped):
+
+```bash
+curl -fsSL https://omc.sh/install.sh | sh
+```
+
+## 2. Register with Claude Code
+
+Open `~/.claude.json` and add an `mcpServers` block (or merge into existing one):
+
+```json
+{
+  "mcpServers": {
+    "omc": {
+      "command": "/absolute/path/to/omnimcode-mcp",
+      "args": [],
+      "env": {}
+    }
+  }
+}
+```
+
+Or run this one-liner (if you have `jq`):
+
+```bash
+BINPATH="/home/thearchitect/OMC/target/release/omnimcode-mcp"  # update path
+jq --arg p "$BINPATH" \
+  '.mcpServers.omc = {"command": $p, "args": [], "env": {}}' \
+  ~/.claude.json > /tmp/claude.json.new && mv /tmp/claude.json.new ~/.claude.json
+```
+
+## 3. Restart Claude Code
+
+`/exit` then relaunch. The MCP tools `mcp__omc__omc_compress_context`, `mcp__omc__omc_memory_store`, etc. are now available to Claude.
+
+## Verify
+
+In any new Claude Code session, ask Claude:
+
+> Use omc_memory_store to remember "hello world", then omc_memory_list to confirm it was stored.
+
+You should see a JSON response with a `content_hash` like `5144560189087515934`.
+
+## Where memory lives
+
+```
+~/.omc/memory/
+├── default/                  ← omc_memory_store with no namespace
+├── omc_session_v08_findings/ ← per-session namespace
+└── <your namespaces>/
+```
+
+Files are append-only logs with one entry per line: `{content_hash}\t{stored_at_unix}\t{base64_encoded_text}\n`. You can grep, diff, or delete them like any other file. Memory+ doesn't lock or encrypt them.
+
+## Troubleshooting
+
+**MCP tools don't appear after restart**
+
+- Check `~/.claude.json` has valid JSON (run `jq . ~/.claude.json`)
+- Check the `command` path resolves to the binary (run `<your_path> --version`)
+- Check Claude Code launch logs for MCP server connection errors
+
+**`mcp__omc__*` tools listed but `InputValidationError` when called**
+
+- Schemas are deferred-loaded. Use ToolSearch with `query: "select:mcp__omc__omc_compress_context"` first (Claude does this automatically in normal use).
+
+**Memory store grows unbounded**
+
+- Default fibtier cap is 232 entries per namespace (sum of first 10 Fibonacci tier sizes). Older entries are evicted from the *index*; raw bodies stay on disk and remain recoverable by hash. Use `omc_memory_evict` to force-compact.