dsh-mneme is a cross-session memory plugin for DeepSeek Harness (DSH). It does not just store your memories — it manages them: background deduplication and merging, conflicts frozen for your review, a fully replayable audit trail, memory kept on your machine, and export to human-readable Markdown.
Mneme (Μνήμη) comes from Mnemosyne, the Greek goddess of memory and dreams — just as autoDream quietly consolidates your memory store in the background.
📰 Recent updates
Date
Version
Headline
2026-10-21
v0.9.4
Three chains each get their missing last link — the three items in this release share one shape: the thing was already built, nothing could call it. ① Agent-driven organizing (#231): the engine landed in src/organize.js back in v0.8 (dryRun comparison report → the agent decides → apply persists, screening out means archive rather than delete, every step leaving a dream_runs receipt), but it had no entry point at all — absent from the tool table, zero hits on both API surfaces, zero .organize( call sites in the repo; only its own tests could reach it. Now it has a tool: memory_organize, behind organizeEnabled, off by default (off = the tool is not even registered, so a model that cannot see it never calls it). ② The profile can finally be derived (#497): the panel's profile card gained a button that reads the active memories, spends one host model call and returns an "as the assistant sees them" draft — a draft only: applying it is another click you make, and your hand-written text is never rewritten by the model; an empty store or a misbehaving model is an error, never an empty draft masquerading as "nothing to extract this time" (profileExtractEnabled, off by default). ③ Personas no longer leak into someone else's session: the default card used to be handed to every identity without a card, so a third-party bot running in the same host — one that carries its own identity — received two "you are ..." claims in every turn, while "switch this card off" in the panel changed nothing; the new personaStrictAddressing (off by default, existing behaviour byte-identical) reclaims both "no card for this identity" and "card explicitly switched off" as inject-nothing. The same release adds the transcript fence and the parse-failure guard for distillation (#494: the root cause of one session being stuck on the same window, retried 20 times and growing more expensive each time; failed rows now always carry the raw output shape, so "what did the model actually print" is answerable afterwards), and the panel's read-only card that called itself "injected text" is now rendered by the backend — it used to show neither the persona lines nor the header and prefix it claimed to mirror.
2026-10-20
v0.9.3
M.O. goes from “diggable” to “actually summoned to dig” — the distillation chain has been fully implemented since v0.9.1 (multi-frame zstd → repeated sequences → absence contrast → draft workflows), yet it had no call site at runtime: every reference in the repo lived in tests. The machine could dig, but nothing ever called it. What was missing was never the algorithm — it was attribution and triggering. This release wires up three things: resolving a project's session bucket from the cwd in the session header (bucket names are a lossy transform of paths whose rule lives outside this repo; when the lookup fails the whole run is skipped rather than degraded into a global sweep — the latter attributes project A's actions to project B, and the result looks perfectly normal); a new nudgeForProject that folds “attribute → mine → persist” into one entry point; and a turn/end hook that runs per project with a 10-minute cooldown, a 4-second budget, deferred to a macrotask, one project at a time, errors only warned. It produces proposals, never drafts (#489): promotion still needs a human, and the panel gained a "distill now" button on the same entry point, differing only in that it does not touch the repo. The same version fixes three “broken but silent” defects: the scope reverse-lookup that had been throwing and silently degrading on every call since v0.8.0, disabling canonical normalization and membership checks (#487); /nudge's write gate, which only intercepted PUT/POST so a token-bearing PATCH/DELETE persisted proposals silently, plus attribution resolution ignoring the budget and bucket names being truncated while being collected — reporting “did not look at everything” as “there is genuinely nothing”; and a multi-frame zstd counter-assertion bound to Node's whole-buffer decode semantics, expired from 24.22.0 (#490).
2026-10-19
v0.9.2
Making silent failures visible — most of what this release fixes isn't a missing feature, it's something broken that never said so. Feature flags have always taken effect at startup, so a lit "changed" badge only meant the value reached the database; there's now a third state, pending restart (#481). The default dreamMaxTokens was sent verbatim as max_tokens and blew past provider caps: 180 consolidations, 0 successes over eight days — the panel can now edit it, and an over-cap request retries once at the limit the provider itself declares (#478). Rows written by auto-distillation got no vector at all; the "deferred to commit" the comment promised never existed (#477). And the CLI treated values starting with -- as new flags — a defect that only surfaces when a random token happens to begin with - (about 1/4096), which is why it hid for a whole release cycle. Also new: a scope-level reversible gate (#471, off by default) that pauses one scope without editing config or restarting.
Headlines only; see the CHANGELOG for the full list.
What problem does it solve
Every time you start a new chat, the AI acts like it's never met you?
dsh-mneme gives DeepSeek Harness cross-session memory. Projects you've discussed, preferences you've mentioned, decisions you've made — the AI remembers them even after you close the window.
Scenario
Without plugin
With plugin
Continue a project discussion from Monday on Wednesday
"Can you describe your project again?"
"You mean the blog refactor from last week? You mentioned wanting to use Astro."
Tell the AI your coding habits
Repeat every session
Set once, remember forever
Close window after organizing research
Notes are lost
Auto-archived, retrievable anytime
But what makes dsh-mneme trustworthy lives in the background you never see. These are the traits that set it apart from "a plugin that just saves things."
Why you can trust it
🧾 Replayable, accountable — every consolidation leaves a "decision receipt": input snapshot + decision detail + result hash. The same run reproduces the same outcome. No silent mis-merges, no untraceable changes.
⚖️ Conflicts freeze, you decide (opt-in) — when two memories contradict, it does not take sides for you. The suspected conflict is parked for review, compared side-by-side in the status-page conflict queue, and resolved with one click (keep A / keep B / mark reviewed). On hard judgments, a human stays in the loop.
🔐 Memories isolated by agent & workspace (opt-in) — with scopeEnabled, every memory is stamped with which agent wrote it and in which workspace; retrieval favors the current scope (weighted hits, out-of-scope demoted but visible); strictScope goes further — memories explicitly scoped to other agents/workspaces become invisible to search and injection (auto carrier labels are demoted only, never hard-blocked). Multiple agents and projects, zero cross-talk.
🌙 It works while you sleep (opt-in) — idle time triggers tiered archiving: frequent memories stay hot, stale ones compress to summaries, old ones archive. The store stays lean as it grows.
🧠 Semantic search that can run fully offline — set embedProvider to local and retrieval uses local embedding + reranking, no API key needed; without an embedder, keyword / BM25 retrieval still works.
📝 Two-way Markdown sync — memories are local .md files you can open and edit; human edits are respected, never clobbered by the machine.
💾 Delete the session ≠ delete the memory — memories are cross-session global knowledge; clearing a chat window keeps what was saved (unbound from sessions since v0.7.11).
How does it compare with Zep / Mem0 / Letta / Hindsight? There is a row-by-row table — storage, retrieval, write-time extraction, offline consolidation, conflicts, forgetting, scoping, auditability, multi-host, offline, license: 11 rows, and "—" does not mean "worse": capability comparison (Chinese).
5-minute quickstart
# Install the plugin (the easy path: npm package name)
dsh plugin --profile web add @modusensus/dsh-mneme
dsh web
Four install sources
Settings → Plugins → Add plugin and dsh plugin add accept four kinds of spec — whatever you paste is what gets installed. This repository is a multi-package repo: the package.json at the root is only a repo shell (private, no dsh field), while the installable plugin lives in dsh-mneme/. So Git and tarball specs must point at that subdirectory; otherwise you install the shell itself.
Why ship an uninstallable shell at the repo root? Because some multi-package detectors (dshfind's plugin probe, for one) only look at the root manifest — without it this repository is judged "not an installable plugin package," which says nothing about whether it actually installs. The root manifest is private + 0.0.0 + carries no dsh field precisely so such tools can find the real subpackage while it can never be installed or published as the plugin itself.
#path: is not optional. Without it you get the root shell (0.0.0, no dsh field) — the host does not treat it as a plugin
tarball
C:\\path\\to\\modusensus-dsh-mneme-0.9.0.tgz
Produced by npm pack inside dsh-mneme/; pnpm pack fails on the bin script's CRLF line endings
local directory
C:\\path\\to\\mneme\\dsh-mneme
Must be absolute — a relative path is rejected outright (a local path must be absolute)
# From source (local directory; edit code, restart, done)
git clone https://github.com/slow-stack/mneme.git
dsh plugin --profile web add "$(pwd)/mneme/dsh-mneme"
# Or straight from Git (no checkout; good for just running a version)
dsh plugin --profile web add 'git+https://github.com/slow-stack/mneme.git#path:/dsh-mneme'
The "Install guide and examples" panel only demonstrates the npm form; all four above are verified. Git and tarball sources get one repository-reachability check at install time (5-second timeout by default).
It works out of the box. To feel its value in five minutes:
Chat — start a session and tell the AI something about your preferences or a project (e.g. "I prefer 4-space indentation.").
Verify — close the window, open a new one. If it recalls what you said, the memory has landed.
Tune — open Settings → Memory Settings and flip the three switches below as needed.
Quick config (optional)
Need
Config key
Default
Change
Fully offline
embedProvider
openai
Change to local
Background consolidation
autoDream
true
Change to false to disable
Structured entity extraction
entityExtractionEnabled
false
Change to true
Memory isolation per agent / workspace
scopeEnabled (add strictScope for stronger isolation — hard blocking applies to explicit declarations only)
false
Change to true
All of these live in DSH Settings → Memory Settings. Full config docs in the Configuration section (Chinese, bilingual file).
Where to put the memory library
The library defaults to ~/.dsh/memory, which is naturally outside any host profile scope; the actual location follows your memoryDir config. If it points inside a profile scope (a path like …/profiles/<name>/…), the library is taken away along with the profile when the host cleans or migrates it (an actual incident recorded in #218). The plugin logs a warning at startup when it detects such a location — advisory only, it never moves your data. Safe practice: keep memoryDir outside profiles (the default already is); to migrate, stop writing → copy the whole directory → point the config at the new location → restart.
🧭 M.O.: make "how it's done" live in the repo (v0.9 beta)
The memory store remembers why a thing was done that way, but not how the thing actually runs. Where a workflow lives decides whether it can be changed at all: as a line in the memory store it has no diff; as a session prompt it exists once; in someone's head it can't be edited and leaves no trace.
So v0.9 moves workflows into the project repository — one file per workflow:
<project>/.mneme/pipelines/<id>.json ← project layer (commit, diff, PR, readable by CI)
<plugin>/pipelines/<id>.json ← global layer (fallback; the package ships none today, on purpose)
One sentence of division of labour: memory is the "why", the repo is the "how", the graph is the "what it looks like".
Guardrails, not tracks — the graph must leave a legal escape hatch: when the agent judges this path wrong this time, the risk tier decides whether it goes ahead and records it, or stops and asks. Skipped means this step wasn't needed (≥3 times → propose deleting the step); bypassed means the whole path was wrong (≥3 times → propose revisiting the path). Counted separately — merged together, neither proposal can ever fire.
Candidates never enter the repo — drafts live in <memoryDir>/candidates/<project-key>/, local only. Ten a day, nine dead: in the repo that's just garbage. Promotion requires both "walked twice (at least once successfully)" and "can state the counterfactual"; even then the system only proposes — commit and push stay a human gate.
The panel and the agent read the same data — render-only means the agent reads nothing. Node states (refuted / trusted / stale / candidate) are derived from run records, never authored; there is no run-record sink yet, so every node is candidate — which is exactly why that beta label has to be on the surface.
Off by default (actionPipelineEnabled). Design trade-offs and pitfalls: docs/WORKFLOWS.md (Chinese).
Screenshots
The panel is bilingual and follows your DSH interface language. English shots below; see the Chinese section for the localized UI.
Privacy
Memories stay on your machine: a local SQLite store plus editable Markdown mirrors, with no mneme server in the path
Memories are Markdown files, human-readable and editable
No mneme API key required; consolidation and summarization use the host model you already configured (autoDream / autoSummarize are on by default)
Want consolidation fully offline too? Point the host at a local model and clear dreamProvider / dreamModel plus summarizeProvider / summarizeModel (setting those routes talks straight to that provider, so switching the host alone will not help) — or just turn off autoDream / autoSummarize
No telemetry, no analytics, no remote logging
Use it in other AI tools (MCP)
The plugin ships a zero-dependency stdio MCP server (standalone npm package mneme-memory, bin mneme-mcp). Any MCP client can mount the six memory tools (memory_save / memory_search / memory_list / memory_get / memory_update / memory_delete).
One-time prerequisites:
DSH is running with the plugin installed (the MCP data plane goes through the plugin's standalone API at 127.0.0.1:8790)
Generate a token in the DSH panel under Settings → External API
Per-client setup (replace <your-token> with the value from the previous step):
openclaw mcp add mneme-memory --command mneme-mcp --env MNEME_TOKEN=<your-token>, or Control UI → Settings → MCP
Legacy mounts keep working: dsh-mneme-mcp + DSH_MNEME_TOKEN remain supported (both the bin and env vars are preserved; no migration needed). If the npm package is not installed globally, use npx as the command with args -p mneme-memory mneme-mcp (an args array in Claude Code/OpenCode; args = ["-p", "mneme-memory", "mneme-mcp"] in Codex). Full config details and security notes: full docs (Chinese).
Serve memories without DSH (standalone daemon)
dsh-mneme-serve runs the memory store as a long-lived data plane — with DSH closed, third-party integrations (web-bridge tools, scripts, your own panels) still read and write the same memories: the Bearer token is shared with the DSH panel/CLI, routes mirror the external API, and a busy port is a hard error (pick either the daemon or DSH's external API, not both). Phase 1 is LLM-free (consolidation/distillation stay with the DSH host); retrieval defaults to local embeddings (runtime + model auto-provisioned on first boot, --embed off to disable).
npm i -g @modusensus/dsh-mneme
dsh-mneme-serve # defaults: ~/.dsh/memory + 127.0.0.1:8790
Community adapters
Community projects that wire mneme into more platforms — not part of this repository; compatibility is tracked by their maintainers:
Browser extension + local service: web chats are distilled into the mneme store and DSH memories are injected back by topic, so both sides share one memory. Embedded (mounts the lib) and remote (standalone API — pairs with the daemon above) modes
Want your project listed? Open a Discussion or send a PR adding a row to this table.
Docs
Doc
Path
Full plugin docs (features / install / config / architecture)
M.O. (Modus Operandi) beta: project-level workflows + candidate tiering & promotion criteria + panel list-and-graph view; settings panel re-folded at "beyond the newcomer" (#427); security & supply-chain hardening (declarative route auth, OSV gate, signed releases); v0.9.1 adds the write side: execution windows, run ledger, attribution candidates, observation sidecar with drift detection, step assert/optional, draft mining from session logs, persona page (per-agent cards); v0.9.2 makes silent failures visible: feature-flag third state "pending restart", scope-level reversible gate (#471), automatic max_tokens downgrade for consolidation (#478); v0.9.3 wires up auto-distillation: resolves the project bucket from the session header's cwd, hooks turn/end, 10-minute cooldown, 4-second budget, proposals only and never drafts (#489), and fixes the scope reverse-lookup that had been silently degrading since v0.8.0 (#487), the /nudge write gate missing PATCH/DELETE, and a multi-frame zstd counter-assertion bound to Node's whole-buffer decode semantics (#490); v0.9.4 supplies the missing last link on three chains: the agent-driven organizing interface finally gets a tool (memory_organize, behind organizeEnabled, off by default — off means the model cannot even see it), the profile can be drafted from memory (profileExtractEnabled, off by default; a draft only — applying it is another user action, and hand-written text is never rewritten by the model), and the persona default card is no longer handed to identities that simply have no card (#497, personaStrictAddressing, off by default); the panel's "injected text" card is now rendered by a single backend source, plus the distillation transcript fence and parse-failure guard (#494)
cd dsh-mneme && npm install
npm test # 2302 tests
npm run stress # three-axis stress test
npm run sync # src → lib sync
Acknowledgements
Provenance of the autoDream concept (ideas credited, implementation original):
Auto Dream in Claude Code (Anthropic, Memory 2.0): the conceptual origin — a background sub-agent consolidates memory files between sessions (dedupe, resolve contradictions, prune decay).
cc-haha: an early reference for the implementation approach.
On top of these, dsh-mneme adds its own engineering: K-Means++ cluster pre-grouping, a typed decision list (keep / merge / archive / conflict / update, plus supersede / differentiate on the sleep side), and a replayable sha256-digest audit chain (dream_runs / receipt_chain). If any source of inspiration is missing, please open an issue.
Related Research
dsh-mneme's design echoes the following public research (every citation below has been verified against its arXiv page; the mechanism mappings are our own, not the papers' claims):
Heat decay & access reinforcement: FadeMem (arXiv:2601.18642) — academic kin of the heat model (exponential decay × access reinforcement × importance modulation).
Conflict resolution & state tracking: StateMemBench (arXiv:2608.19652) — a benchmark for tracking evolving state; C1 conflict adjudication (no stale reads after supersede) treats it as its acceptance target.
When to forget / scope gating: PersistBench (arXiv:2602.01146); presentation-layer mitigation in Structured Memory (arXiv:2608.08300).
Field survey: Write–Manage–Read survey (arXiv:2603.07670) — the write/manage/read taxonomy matches the plugin's overall shape.
Months-scale reliability: Memory as Infrastructure (arXiv:2609.05510) — the same "memory as infrastructure" school as the sha256 audit chain and fail-safe degradation.
Adjacent systems (contrast): Zep (temporal knowledge graph), Mem0 (production-grade extraction) and Hindsight (retain / recall / reflect) extract with LLM at write time and retrieve via vectors/graphs; dsh-mneme instead keeps consolidation replayable with a full audit trail, freezes conflicts for human review, and keeps memory local by default.
📜 License
MIT
M
Mneme Memory
io.github.modusensus·223 ดาว·
Cross-session memory for AI coding agents via six tools; local-first SQLite store.
