recallnest 2.6.0 → 3.0.0

package/CHANGELOG.md

@@ -1,5 +1,196 @@
 # Changelog
 
+## v3.0.0 — Node 22, and conclusions that can be used (2026-08-24)
+
+Two things make this a major release: the runtime floor moves, and a synthesized
+conclusion can finally reach stable memory. Everything else here is either in service of
+those or was found while doing them.
+
+### Changed
+
+- **`engines.node` is now `>=22`** (was `>=18.14.1`). This is the only breaking change in
+  the release; Bun users are unaffected.
+- **`openai` migrated from `^4.0.0` to `^7.5.0`**, which removes the
+  `openai@4 → formdata-node@4.4.1 → node-domexception@1.0.0` deprecated chain from the
+  dependency tree. Every `openai` release since v5 has zero dependencies, so the chain
+  disappears on any upgrade — v7 was chosen because it declares `engines.node >= 22.0.0`,
+  making the Node floor and the dependency cleanup one decision instead of two. Verified
+  against the SDK rather than its migration guide: the guide documents the `httpAgent`
+  removal, the move to built-in `fetch`, and the Node 22 floor, but says nothing about the
+  three things this codebase actually depends on — `embeddings.create`, the second
+  `RequestOptions` argument on `chat.completions.create`, and the error classes exposed as
+  statics on the default export. All three hold.
+- **MCP tool count is 44**, up from 43 (`promote_synthesis`, governance tier).
+
+### Added
+
+- **`promote_synthesis` (MCP) and `recallnest promote-synthesis` (CLI)** — a promotion road
+  for dream-synthesized conclusions. `buildDerivedBoundary` marks every cluster insight and
+  cross-memory pattern `layer: "evidence"` on purpose, and `shouldUseStableMemoryResult`
+  refuses the evidence layer, so a synthesized conclusion could never take part in stable
+  memory regardless of how well supported it was. Eligibility comes from the conclusion's
+  own validated evidence set — `synthesis_contract >= 2`, at least two distinct still-active
+  evidence memories — rather than from repetition, because a synthesis is already a
+  cross-entry aggregate. It abstains when the evidence cannot be resolved, counts every
+  rejection reason, defaults to dry-run, never modifies the synthesized row, and writes
+  through the existing `promoteMemory` path so `canonicalKey` dedup makes a re-run a
+  revision instead of a duplicate.
+- **Retrieve audit rows carry revision and provenance.** `retrieved[]` records each served
+  result's id, `evolution.version`, lifecycle status, and boundary layer/authority;
+  `retrievedTotal` appears when the capped list is shorter than the truth. Beliefs are
+  revised in place — the canonical id survives, the version increments, the old text
+  remains as a `superseded` row — so a row saying only `hits=N` could not distinguish a
+  current answer from a stale one after the fact.
+- **HTTP contract tests for embeddings and chat completions** (`openai-contract.test.ts`).
+  Every prior embedder/LLM test stubbed the SDK client, so none of them touched a socket
+  and a transport-level regression would have passed all of them. These drive the real
+  `Embedder` and `LLMClient` through the real SDK against a loopback `node:http` server,
+  covering success, error, and timeout for the default OpenAI request shape plus the Jina
+  (`task`/`normalized`/`dimensions`) and Qwen-compatible profiles. No network egress, no
+  vendor credentials, no paid calls.
+- **A repeatable regression for verbatim self-recall** (`verbatim-self-recall.test.ts`).
+  A long, older, rarely-read entry can fail to be recalled by words copied out of its own
+  body while short, fresh, frequently-read entries outrank it. The reproduction pins the
+  mechanism: the entry is *not* filtered — `hard_min_score`, `layer_admission` and
+  `noise_filter` each drop zero rows and its score clears the threshold — it is admitted
+  and then ranked last. The ranking fix is deliberately not in this release.
+- **`scripts/tier-exemption-snapshot.ts`** — captures tier and decay-exemption distribution
+  so "we did not change tiers" becomes checkable later rather than asserted.
+
+### Added — synthesis quality (generation side)
+
+Six changes to what `dream` produces, from a full diagnostic on 2026-08-22 whose core
+finding was that **derived memories had a lower conclusion density than their own input**:
+over the same 40–160 character band, with a deterministic regex and no LLM judge,
+hand-written pivots scored 40.4%, raw transcripts 25.1%, insights 14.4%, patterns 12.1%.
+Synthesis was subtracting.
+
+- **`cluster_insight` no longer routes through `generateL0`.** That prompt is a chunk
+  summariser — it asks for a one-line summary for retrieval and explicitly preserves ports,
+  IPs, URLs and file paths verbatim; it never asks for a conclusion, a cause, or a decision.
+  The new `synthesizeClusterInsight` goes through `synthesis-contract.ts`, asks for a
+  reusable conclusion, and **may abstain**. The old path's `if (!insight)` only fired when
+  the LLM call itself failed, so "this cluster is not worth keeping" had no way to be
+  expressed and all 2,427 rows were episode summaries by construction.
+- **`extractPattern` changed target concept and now requires evidence.** The old prompt
+  asked for recurring preferences, behavioural tendencies and values — a personality-profile
+  frame, which produced dispositional attribution in 56.1% of outputs against 1.4% in the
+  source material. The old prompt also claimed to want "at least 2 memories as supporting
+  evidence" while the implementation neither received nor checked any numbering, making the
+  sentence free. Two pieces of evidence is now a hard gate.
+- **`validateSynthesis` runs before anything is written.** The old path checked only
+  `response.length < 5`, which is how 28 memories ended up holding their own system prompt
+  as their body. `has` must be a boolean, length must be in range, the text must not echo
+  the prompt, and evidence numbers must refer to real, distinct cluster members. Failures
+  are counted by reason instead of collapsing into one `null`.
+- **Pattern and insight are decoupled.** `if (!insight) { continue; }` bound two different
+  target concepts to one fate: an abstaining insight meant pattern extraction never ran.
+  They now fail and abstain independently, and "this round produced nothing" is judged on
+  whether the cluster had any effect at all rather than on whether an insight existed.
+- **Derived rows carry an explicit `boundary`.** All 4,749 historical derivatives had none;
+  the retriever's `isEvidenceLayer` fell back to scope matching, so 96.4% were classified
+  correctly only because they happened to sit in a `cc:`/`codex:` scope — by luck of naming,
+  not by design. The remaining 173 sat in `memory`/`project:*` scopes and silently held
+  durable authority. Derived rows are `layer: "evidence"`, `authority: "distillation"`.
+- **`synthesis_contract` version stamp**, so "which code produced this output" stops being
+  a guess from timestamps. v2 adds a single-JSON-object constraint: v1 emitted multiple JSON
+  objects on 3.3% of calls (all with `finish_reason: stop`, unrelated to truncation), which
+  made the whole response unparsable; the same measurement after the constraint is 0.0%.
+
+### Added — memory utility (MemOS value backtracking)
+
+- **Value-backtracking join key (P0).** `workflow_observe` now records `readerId` and
+  `recalledIds`, supplying the `(memory_id, outcome)` pairing the database never had: one
+  side had outcomes without participants (observations did not record memories), the other
+  had participants without outcomes (the access tracker recorded hits but not task success).
+  New `src/recall-ledger.ts` keeps process-level reader identity and a retrieval-hit ledger;
+  managed observations from `resume_context` / `checkpoint_session` carry it automatically.
+  New CLI `memory-utility <id>` reports the success rate of tasks a memory took part in.
+- **`utility` column (P1).** `src/memory-utility.ts` weights outcomes (success +0.8 /
+  corrected +0.2 / missed −0.3 / failure −0.8) with a 30-day half-life; **it can be
+  negative**. It lands in `metadata.utility` and deliberately not in `importance`, which is
+  threshold-valued (≥0.95 grants permanent decay exemption) and already written by structured
+  memory. Retrieval gained `utilityWeight`, default 0 (off), feeding ranking only — not tier,
+  not decay exemption.
+- **Cross-source criterion for promotion (P2).** `scanForPromotions` gained
+  `minDistinctSources` (default 2). Counting "how many similar cases" and "how many distinct
+  episodes" differ in dimension, not degree — hitting the same problem three times is one
+  experience repeated, which belongs on the failure-burst path instead. It **abstains** when
+  source pointers are unavailable: only 1.2% of cases across the database carry a `src:` tag,
+  so judging strictly would mostly punish three different problems solved on one day.
+
+### Fixed
+
+- **A rate-limit reply could trigger an unbounded request storm.** Found by the new contract
+  tests. `embedSingle` retried a context-length error by chunking, and each chunk recursed
+  back into `embedSingle`, able to re-enter the same branch. Two facts made that
+  non-terminating: `smartChunk` returns short text unchanged, so the recursion re-embedded
+  the identical string and reproduced the identical error; and the gate
+  `/context|too long|exceed|length/i` also matches rate-limit wording — both
+  `"Rate limit exceeded"` and `"429 quota exceeded"` trigger chunking. Measured before the
+  fix: **61,724 requests in five seconds** against an endpoint asking us to slow down. The
+  batch path had the same shape. The missing terminating condition is now present: chunking
+  that cannot produce anything smaller than its input throws instead of recursing, and a
+  chunk's own embed call cannot re-enter the branch. After: 4 ms, one request, correct error.
+- **Multiple `AccessTracker` instances in one process no longer invent separate readers.**
+  `createComponentResolver` caches components per profile, so one session opening two
+  profiles produced a phantom second reader, inflating `distinctReaderCount` and the
+  skill-promotion read boost. The implementation now matches what `access-tracker.ts` says
+  about itself ("one stdio MCP server process ≈ one CC session").
+
+### Documentation
+
+- `docs/memory-boundary-contract.md` documents both promotion scans, why their eligibility
+  gates differ, and the abstention rule.
+- `retriever.ts` records that `candidatePoolSize` above 20 has never had any effect — both
+  candidate legs land in `store.ts`'s `clampInt(limit, 1, 20)`. The clamp has been there
+  since the first commit while the 2026-07-16 tuning only touched the retriever, so that
+  `30` was inert from the day it landed. Left alone deliberately: raising it means widening
+  the candidate pool, which was measured and rejected on 2026-08-22.
+
+### Upgrade notes
+
+- **Node 22 or newer is required.** This is the release's only breaking change.
+- Existing LanceDB data opens in place; no export/import step.
+- `promote_synthesis` defaults to dry-run and writes nothing until `dryRun=false`.
+- `audit.jsonl` retrieve rows are larger now that they list what was served. The list is
+  capped at 10 entries with `retrievedTotal` marking truncation. Rotation is still manual;
+  archive it if it approaches 50 MB.
+- `utilityWeight` defaults to 0 and `metadata.utility` is written only by an explicit
+  `memory-utility --apply` run, so the MemOS work above is **available but not yet acting on
+  anything**. The resident MCP server was restarted on 2026-08-24, so `readerId` is now being
+  written (verified end-to-end on a fresh server: a `workflow_observe` call landed an
+  observation carrying `readerId`); `recalledIds` only gets a value when a retrieval hit
+  actually occurs, and no row carries `metadata.utility` yet because `--apply` has not been
+  run. Real data therefore starts accumulating from this release forward, not before it.
+  This is the intended shadow period, not a defect.
+
+### Verification
+
+- 2,324 tests pass across 165 files, 0 fail (2,281 at the 3.0 gate → +14 contract, +6 audit
+  revision, +8 verbatim self-recall, +15 synthesis promotion). Verified under three
+  feature-flag combinations, including the CI default, after CI caught one assertion
+  that had been reading the developer's local `.env` rather than product behaviour.
+- The deprecated chain is absent from `npm ls`, `node_modules/`, `bun.lock` and
+  `package-lock.json`; installed `openai@7.5.0` reports zero dependencies and
+  `engines.node >= 22.0.0`.
+- SDK compatibility was measured, not assumed: 20 sandbox probes against v7.5.0 (9 API
+  surface, 11 loopback-HTTP runtime) plus a `tsc --strict` check of all five call sites,
+  with a deliberately-broken control run to confirm the type check actually reports errors.
+- `promote_synthesis` was exercised read-only against the live database: 52 contract-stamped
+  derivatives exist; `project:codex-self-evolution` yielded 10 candidates from 10 examined,
+  `project:antigravity-cli` 4 from 9 (5 below importance), `learnings` 3 from 4 (1 with too
+  few distinct sources). Nothing was written.
+- The verbatim self-recall and synthesis-promotion suites were both reverse-verified —
+  removing the behaviour each asserts turns the relevant tests red and no others.
+
+### A note on npm history
+
+`recallnest@2.6.1` was a maintenance release published before Trusted Publishing was
+configured for this package and therefore carries no build provenance. That describes how it
+was published; it is not retroactively fixable, since the same npm version cannot be
+republished to add provenance.
+
 ## v2.6.0 — Cross-process consistency and reliable distribution (2026-08-13)
 
 ### Added

package/README.md

@@ -2,17 +2,17 @@
 
 # RecallNest
 
-**Shared Memory Layer for Any MCP Client — Claude Code, Codex, Kimi, Antigravity, Gemini CLI**
+**Shared Memory Layer for Every AI Client — CLI agents, desktop apps, your own scripts**
 
-*One memory. Every terminal. Context that survives across windows.*
+*One memory. Every client. Context that survives across windows — and across machines.*
 
 A local-first memory system backed by LanceDB that turns scattered conversation history into reusable knowledge — shared across your coding agents, recalled automatically.
 
 [![GitHub](https://img.shields.io/github/stars/AliceLJY/recallnest?style=social)](https://github.com/AliceLJY/recallnest)
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
-[![Runtime](https://img.shields.io/badge/Runtime-Bun_|_Node.js_18+-f9f1e1?logo=bun)](https://bun.sh)
+[![Runtime](https://img.shields.io/badge/Runtime-Bun_|_Node.js_22+-f9f1e1?logo=bun)](https://bun.sh)
 [![LanceDB](https://img.shields.io/badge/LanceDB-Vector+FTS-orange)](https://lancedb.com)
-[![MCP](https://img.shields.io/badge/MCP-43_tools-blue)](https://modelcontextprotocol.io)
+[![MCP](https://img.shields.io/badge/MCP-44_tools-blue)](https://modelcontextprotocol.io)
 [![CI](https://github.com/AliceLJY/recallnest/actions/workflows/ci.yml/badge.svg)](https://github.com/AliceLJY/recallnest/actions/workflows/ci.yml)
 [![CC Plugin](https://img.shields.io/badge/Claude_Code-Plugin-blueviolet)](https://github.com/AliceLJY/recallnest)
 
@@ -29,6 +29,55 @@ Coding agents forget everything between windows. Your context — project config
 RecallNest solves this: **a single LanceDB-backed memory layer that your coding agents read and write**. Context stored in one window is auto-recalled in another. Sessions checkpoint on exit and resume on start. Memory decays, evolves, and self-organizes — not just raw log storage.
 
 
+## Who Can Connect
+
+**The data layer does not know what your client looks like.** RecallNest exposes the same LanceDB store through three outlets, so the right one is picked per client — not per protocol.
+
+| What your client can do | Route | Verified with |
+|---|---|---|
+| Run a local command (CLI agent) | **MCP over stdio** | Claude Code, Codex, Kimi, Antigravity |
+| Run a local command (GUI app, MCP config filled by hand) | **MCP over stdio** | Doubao desktop — same shape as Cherry Studio / ChatBox |
+| Only speak HTTP | **HTTP API** | custom agents, scripts, cron |
+| Run on another machine | swap the stdio command for `ssh <host> recallnest-mcp` | four clients on a laptop reading one store on a home server |
+
+Two consequences worth stating plainly:
+
+- **Not tied to one protocol.** A GUI chat app that supports MCP config connects the same way a terminal agent does. A client that can only issue HTTP requests still reads the same memory.
+- **Not tied to one machine.** Because the MCP transport is stdio, the launch command is yours to define — point it at `ssh` and every client on every machine shares a single source of truth instead of each host growing its own database.
+
+Adding a client does not mean changing RecallNest. A capable client writes one config line; a limited one gets a thin gateway in front of the HTTP API.
+
+### AI apps on a phone: the read-only gateway
+
+The HTTP API (`:4318`) binds to `127.0.0.1` and rejects any request whose Host header is not local. That is **deliberate** — it also exposes write routes (`/v1/store`, `/v1/checkpoint`), so putting it on a public address would hand out write access.
+
+To let an AI app on your phone read the same memory, put a read-only gateway in front:
+
+```bash
+openssl rand -hex 32 > ~/.config/recallnest/gateway-token
+chmod 600 ~/.config/recallnest/gateway-token
+
+bun run api        # local API on :4318
+bun run gateway    # read-only gateway on :8791 → forwards to :4318
+```
+
+The gateway allows read routes only (`/recall`, `/search`, `/stats`, `/health`); **every write route is a 404**. Bearer token compared in constant time, per-minute rate limit, hard caps on request and response size. Put it behind a tunnel (Tailscale Serve/Funnel, Cloudflare Tunnel, …) to reach it from a phone.
+
+```bash
+curl -X POST https://<your-tunnel>/recall \
+  -H "Authorization: Bearer $(cat ~/.config/recallnest/gateway-token)" \
+  -H 'content-type: application/json' \
+  -d '{"query":"how did we fix that deploy issue","limit":3,"allScopes":true}'
+```
+
+Optional: set `RECALLNEST_GATEWAY_FILE_ROOTS="notes=/abs/path,wiki=/abs/path"` to add `GET /files/search`, a read-only ripgrep search over markdown directories you name (the query is passed as an argv element, never through a shell). Leave it unset and the route does not exist.
+
+> The gateway also binds to `127.0.0.1` by default — exposing it is the tunnel's job. Evaluate that risk yourself.
+
+This is how the author connected [OpenMinis](https://github.com/OpenMinis/OpenMinis) on an iPhone: the phone app reaches the gateway over a Tailscale Funnel and queries the same memory store. The interesting part is what it reads back — its own history. Those conversations get exported, flow back, and are indexed, so a phone agent that cold-starts every time ends up with memory that survives its sessions.
+
+
+
 ## Quick Start
 
 ### Option A: Claude Code Plugin (recommended)
@@ -55,7 +104,7 @@ npm install -g recallnest      # install globally
 recallnest doctor
 ```
 
-Works with Node.js 18+ (via tsx) or Bun. No git clone needed.
+Works with Node.js 22+ (via tsx) or Bun. No git clone needed.
 
 ### Option C: Manual setup
 
@@ -96,7 +145,7 @@ curl http://localhost:4318/v1/stats
 
 ```bash
 bash integrations/claude-code/setup.sh
-bash integrations/gemini-cli/setup.sh
+bash integrations/agy/setup.sh
 bash integrations/codex/setup.sh
 ```
 
@@ -196,6 +245,71 @@ bun run src/ui-server.ts
 
 ---
 
+## New in v3.0: A Supported Runtime, and Conclusions That Can Be Used
+
+v3.0 is a major release for one reason that shows up on install and one that shows up in
+how memory behaves.
+
+**The runtime boundary moved to Node 22.** RecallNest had been carrying `openai@4`, which
+pulls in the deprecated `formdata-node` → `node-domexception` chain. Every `openai` release
+since v5 has zero dependencies, so the chain disappears on any upgrade — but v7 declares
+`engines.node >= 22.0.0`, which makes "raise the Node floor" and "move off a deprecated
+dependency chain" the same piece of work rather than two. `engines.node` is now `>=22`.
+This is the breaking part of the major.
+
+**A synthesized conclusion can now reach stable memory.** `dream` writes cluster insights
+and cross-memory patterns on the evidence layer deliberately — a model re-reading its own
+memories is a lead to its sources, not authority over them — but stable-memory selection
+refuses the evidence layer outright. The consequence was absolute: no matter how well
+supported a synthesized conclusion was, nothing downstream could lean on it. `promote_synthesis`
+(MCP) and `recallnest promote-synthesis` (CLI) give it a road, gated on the conclusion's own
+validated evidence set rather than on repetition, because a synthesis is already a
+cross-entry aggregate. The synthesized row is never modified; promotion writes a separate
+durable entry carrying `promotedFrom` back to it, through the same path and the same
+`canonicalKey` dedup as every other promotion.
+
+Also in this release:
+
+- **Retrieve audit rows say what was served.** They used to record the query and a hit
+  count. Because beliefs are revised in place — the id stays, the version increments, the
+  old text survives as a `superseded` row — "memory X was retrieved" was ambiguous across
+  every belief change. Rows now carry each result's id, revision, lifecycle status, and
+  boundary. The list is capped, and a capped list says so.
+- **HTTP contract tests for embeddings and chat completions.** Every previous test stubbed
+  the SDK client, so nothing exercised a socket, and a transport-level regression would
+  have passed all of them. These drive the real classes through the real SDK against a
+  loopback server, covering success, error, and timeout for the default OpenAI shape plus
+  the Jina and Qwen-compatible profiles. No network egress, no vendor credentials.
+- **Fixed: a rate-limit reply could trigger an unbounded request storm.** Found by those
+  tests. The embedder retried a context-length error by chunking, the chunker returns short
+  text unchanged, and the gate that decided "this is a context error" also matched
+  rate-limit wording — so a 429 re-embedded the same text forever. Measured at over 61,000
+  requests in five seconds against an endpoint asking us to slow down. Failure is bounded now.
+- **A known recall gap is now a runnable regression.** A memory that is long, older, and
+  rarely read can fail to be recalled by words copied out of its own body, while short,
+  fresh, frequently-read entries outrank it. It is a ranking problem, not a filtering one —
+  the entry clears every threshold and then places last. The reproduction is checked in; the
+  ranking fix is not in this release.
+- **44 MCP tools** across three tiers, up from 43.
+
+### Upgrading from v2.6
+
+- **Node 22 or newer is required.** Bun users are unaffected. This is the only breaking
+  change in the release.
+- Existing LanceDB data is opened in place. No export or import step.
+- `promote_synthesis` defaults to dry-run and writes nothing until `dryRun=false`.
+- `audit.jsonl` rows for retrievals are larger now that they list what was served. Rotation
+  is still manual; archive it if it approaches 50 MB.
+
+### A note on npm history
+
+`recallnest@2.6.1` on npm was a maintenance release published before Trusted Publishing was
+configured for this package, so it carries no build provenance. That is a fact about how it
+was published, not a defect in the package, and it is not retroactively fixable — the same
+npm version cannot be republished to add provenance.
+
+---
+
 ## New in v2.6: Reliable Cross-Process Memory and Distribution
 
 v2.6 turns the development since v2.5.4 into a release-ready upgrade:
@@ -266,8 +380,8 @@ v2.2 hardened retrieval quality; v2.3 opens RecallNest to external data sources
 ┌──────────────────────────────────────────────────────────┐
 │                     Client Layer                          │
 ├──────────┬──────────┬──────────┬──────────────────────────┤
-│ Claude   │ Gemini   │ Codex    │ Custom Agents / curl     │
-│ Code     │ CLI      │          │                          │
+│ Claude   │ Anti-    │ Codex    │ Custom Agents / curl     │
+│ Code     │ gravity  │          │                          │
 └────┬─────┴────┬─────┴────┬─────┴──────┬──────────────────┘
      │          │          │            │
      └──── MCP (stdio) ───┘     HTTP API (port 4318)
@@ -277,7 +391,7 @@ v2.2 hardened retrieval quality; v2.3 opens RecallNest to external data sources
 │                   Integration Layer                       │
 │  ┌─────────────────────┐  ┌────────────────────────────┐ │
 │  │  MCP Server         │  │  HTTP API Server           │ │
-│  │  43 tools           │  │  21 endpoints              │ │
+│  │  44 tools           │  │  21 endpoints              │ │
 │  └─────────┬───────────┘  └──────────┬─────────────────┘ │
 └────────────┼─────────────────────────┼───────────────────┘
              └──────────┬──────────────┘
@@ -323,7 +437,7 @@ v2.2 hardened retrieval quality; v2.3 opens RecallNest to external data sources
 
 RecallNest serves two interfaces:
 
-- **MCP** — for any MCP client: Claude Code, Codex, Kimi, Antigravity, Gemini CLI (native tool access)
+- **MCP (stdio)** — for any client that can launch a command: CLI agents (Claude Code, Codex, Kimi, Antigravity) and GUI apps that accept an MCP config (Doubao, Cherry Studio, ChatBox)
 - **HTTP API** — for custom agents, SDK-based apps, and any HTTP client
 
 ### Agent framework examples
@@ -339,7 +453,7 @@ Examples live in [`integrations/examples/`](integrations/examples/):
 ---
 
 <details>
-<summary><strong>MCP Tools (43 tools)</strong></summary>
+<summary><strong>MCP Tools (44 tools)</strong></summary>
 
 | Tool | Description |
 |------|-------------|
@@ -351,6 +465,7 @@ Examples live in [`integrations/examples/`](integrations/examples/):
 | `store_case` | Store a reusable problem-solution pair as durable `cases` memory |
 | `promote_memory` | Explicitly promote evidence into durable memory |
 | `promote_scan` | Scan recent evidence and auto-promote qualifying memories into durable storage |
+| `promote_synthesis` | Scan dream-synthesized conclusions and promote the ones their own evidence set supports |
 | `list_conflicts` | List or inspect promotion conflict candidates |
 | `audit_conflicts` | Summarize stale/escalated conflict priorities |
 | `escalate_conflicts` | Preview or apply conflict escalation metadata |
@@ -492,6 +607,8 @@ RecallNest auto-detects babel-memory at startup — no configuration needed. Wit
 
 RecallNest is actively maintained. All major architecture phases are complete — see the full [Roadmap](ROADMAP.md) for current priorities and future plans.
 
+Maintainers: see [Publishing RecallNest](https://github.com/AliceLJY/recallnest/blob/main/docs/releasing.md) for the npm Trusted Publishing, validation, and recovery process.
+
 ---
 
 ## Relationship to memory-lancedb-pro
@@ -499,7 +616,7 @@ RecallNest is actively maintained. All major architecture phases are complete
 RecallNest started as a fork of [memory-lancedb-pro](https://github.com/CortexReach/memory-lancedb-pro) and shares its core ideas around hybrid retrieval, decay modeling, and memory-as-engineering-system. The key difference:
 
 - **memory-lancedb-pro** is an OpenClaw plugin — it adds long-term memory to a single OpenClaw agent.
-- **RecallNest** is a standalone memory layer — it serves any MCP client (Claude Code, Codex, Kimi, Antigravity, Gemini CLI) simultaneously through MCP + HTTP API, with session continuity, structured assets, and conflict management built in.
+- **RecallNest** is a standalone memory layer — it serves CLI agents, GUI chat apps and plain HTTP callers simultaneously through MCP + HTTP API, with session continuity, structured assets, and conflict management built in.
 
 ## Credit
 
@@ -520,9 +637,9 @@ Part of the **小试AI** open-source AI workflow:
 |---------|-------------|
 | [babel-memory](https://github.com/AliceLJY/babel-memory) | Multilingual preprocessing for BM25 — 27+ languages, zero deps |
 | cc-empire *(private)* | Hooks/rules/methodology — the connective tissue of the whole ecosystem |
-| [telegram-ai-bridge](https://github.com/AliceLJY/telegram-ai-bridge) | Telegram bots for Claude, Codex, and Gemini |
+| [telegram-ai-bridge](https://github.com/AliceLJY/telegram-ai-bridge) | Telegram bots for Claude, Codex, Agy, and Kimi |
 | [tg-bridge-channel](https://github.com/AliceLJY/tg-bridge-channel) | Sister Telegram bridge using Claude Agent View background sessions |
-| [wechat-ai-bridge](https://github.com/AliceLJY/wechat-ai-bridge) | Run Claude Code / Codex / Gemini in WeChat with session management |
+| [wechat-ai-bridge](https://github.com/AliceLJY/wechat-ai-bridge) | Run Claude Code / Codex in WeChat with session management |
 | [openclaw-tunnel](https://github.com/AliceLJY/openclaw-tunnel) | Docker ↔ host CLI bridge (maintenance mode — LanceDB test only) |
 | [digital-clone-skill](https://github.com/AliceLJY/digital-clone-skill) | Build digital clones from corpus data |
 | [claude-code-studio](https://github.com/AliceLJY/claude-code-studio) | Multi-session collaboration platform for Claude Code |