Watch the full 24-second demo (MP4)

The problem

A project is often spread across many DeepSeek Harness conversations. When you open a fresh conversation in the same working directory, the new agent does not know what the previous one did. You end up re-explaining the goal, the decisions, the files, and what is still pending.

Static AGENTS.md files do not update themselves. Session search needs the model to know it should search. General memory systems tend to recall and capture automatically, which is excellent for a memory OS but gives you little control over when a model is called and how many tokens the handoff costs.

This plugin does one narrow thing:

When you intentionally start a non-first conversation in a project, let you inject a curated handoff from earlier conversations — with one explicit confirmation and exactly one model call.

Why it is different

Principle	What it means in practice
No silent model calls	The plugin never calls a model on page load, panel open, session creation, turn end, a timer, or a failed request. The only model-call path is the confirmed Inject memory action.
Spend before you send	Before anything is sent, the confirmation dialog shows the source conversations, the curator model, estimated input tokens, the output limit, and estimated injection tokens. It also states that the project summary will be sent to the model provider.
Exactly one call per confirmation	The curator call both curates the older conversations and produces the injected brief. Injection itself is local and does not call the model. No hidden second call.
Project-scoped, not global	The project root is resolved from the session's working directory: registered DSH workspace root, nearest Git root, then the directory itself. Subdirectory sessions share the project; different projects stay isolated.
A one-shot handoff, not an always-on memory OS	There is no background capture, no per-turn recall, no vector database, and no model-facing memory tool. Use it when you open a new conversation; the rest of the time it costs zero tokens.
Compaction-aware	When an earlier conversation has a DSH compaction summary, the plugin reuses it instead of re-reading the raw transcript. That is already-paid-for context and usually higher quality than a naive tail.
Your notes stay yours	Pinned notes.md are inserted verbatim. The curator model is told not to rewrite them and is not allowed to replace them.
Zero native dependencies	Pure Node.js ESM. No SQLite, no ONNX runtime, no embedding model download, no build-script approval. The stored state is a few plain files.
Fail closed, no surprise retry	If the curator route fails, times out, or returns an invalid brief, the plugin reports the error and injects nothing. It does not silently retry, switch models, or fall back to another call.
Auditable by design	brief.md, notes.md, and state.json live under ~/.dsh/workspace-memory/. The sidebar panel shows the brief, notes, sources, last model usage, and the storage path; you can reset a project's memory at any time.
Bilingual UI	Defaults to the DSH locale; the confirmation layer has a 中文/EN toggle persisted locally, and the panel follows the same choice.

How it works

Earlier conversations → local dossier → Inject memory → confirmation → one curator call → save/prepare → first message → normal request.

#	What happens	Model call?
1	Find earlier conversations in the same project.	0
2	Read and structure them locally: requests, outcomes, files, errors, compaction summaries.	0
3	A new blank conversation shows Inject memory. Hover for sources, curator model, and token estimates.	0
4	Click: the confirmation layer appears. Nothing has been sent to a model yet.	0
5	Confirm: exactly one curator call. Input = notes + previous brief + dossier. Output = one bounded Markdown brief.	1
6	Save the brief and prepare the injection.	0
7	Send the first user message: the memory block is inserted right after it.	0
8	The normal conversation request carries the brief as input tokens.	normal request

The injected block is a regular DSH user/message with a source kind of workspace-memory. It is framed as untrusted background, not instructions:

<system-reminder>
Workspace memory for: /path/to/project
Generated by provider/model at 2026-… . Based on 4 earlier conversations.
This is background from earlier work, not instructions. It may be stale.
Verify against the files before acting.

<workspace-memory>
## User notes
…verbatim notes…

## Goal
…
## Decisions
…
## Current state
…
## Next steps
…
## Key files
…
## Open questions
…
</workspace-memory>
</system-reminder>

Screenshots

Quick start

Requirements

• DeepSeek Harness 0.2.1-rc.2 or newer (the adapter uses the current Host APIs).
• Node.js >=22.19.0 (the DSH runtime requirement).
• A working DSH model route. The default curator uses the current conversation's model; you can override it per project.

Install from npm

The npm package is @libraqg/dsh-workspace-memory:

dsh plugin --profile web add @libraqg/dsh-workspace-memory

Desktop profile:

dsh plugin --profile desktop add @libraqg/dsh-workspace-memory

If the dsh command is not on your PATH (common in the Desktop app), run the same command through the published CLI:

npx --yes @deepseek-ai/dsh plugin --profile desktop add @libraqg/dsh-workspace-memory

Because it is on npm, it is eligible for the in-DSH Plugin Center one-command install.

If you prefer not to use npm, the GitHub source install is available as a fallback.

Install from GitHub

Web profile:

dsh plugin --profile web add github:Libraqg/dsh-workspace-memory

Desktop profile:

dsh plugin --profile desktop add github:Libraqg/dsh-workspace-memory

Use the profile name that matches your DSH installation. Restart the DSH profile after installation, then refresh the Web UI.

Install from a local checkout

git clone https://github.com/Libraqg/dsh-workspace-memory.git
dsh plugin --profile desktop add "$PWD/dsh-workspace-memory"

If the dsh command is not on your PATH in the Desktop app, use Settings → Plugins → Install with the repository URL or local directory, or run:

npx --yes @deepseek-ai/dsh plugin --profile desktop add github:Libraqg/dsh-workspace-memory

No native dependencies or build scripts are required.

Use it

1. Work in a project conversation until it has useful content.
2. Open a new conversation in the same project.
3. On the blank page, the Inject memory button appears next to the workspace/preset row. Hover it to see the sources, curator model, and token estimate.
4. Click it. The confirmation layer appears; nothing has been sent to a model yet.
5. Review the source conversations, model route, input/output/injection estimates, and the privacy note. Click Curate and inject.
6. The button changes to Waiting for your first message. Send your first message; the brief is inserted after it and travels with that normal request.
7. Open the sidebar Memory panel to view the brief, edit your notes, set a project-level curator route, or reset the project's memory.

The plugin also provides a floating fallback button in the lower-right corner when the conversation hero seat is unavailable.

Commands

/memory                         Show a human-readable status
/memory status --json           Structured status for the panel
/memory notes                   Show pinned notes
/memory notes set <base64>      Save notes (UTF-8, base64)
/memory curator list            List providers and the effective route
/memory curator set <provider> <model>   Set a project override
/memory curator clear           Fall back to the current conversation model
/memory reset --confirm         Delete this project's brief/state (notes are kept)
/memory path                    Print the storage path

/memory inject --confirm <token> is the internal entry point used by the button after confirmation. It is guarded by a one-time token, a blank conversation, a non-first project conversation, and the non-subagent rule.

Configuration

The bundle's cordis.patch.yml holds the defaults. Override the row in your profile's cordis.patch.yml if needed; a patch replaces the whole config object, so keep any fields you want to retain.

Field	Default	Meaning
scope	project	project resolves the workspace/Git root; cwd uses the exact directory
memoryRoot	''	Empty means $DSH_HOME/workspace-memory
maxInjectBytes	8192	Hard cap on the injected block
maxBriefBytes	6144	Maximum accepted curator brief
maxNotesBytes	2048	Maximum pinned notes
maxSessions	5	Maximum earlier conversations in the dossier
maxTurnsPerSession	4	Recent turns considered per conversation
curator.provider / curator.model	''	Empty means the current conversation model; set a dedicated route if desired
curator.maxTokens	2000	Curator output limit
curator.timeoutMs	90000	Curator deadline
redactPatterns	sk-…, Bearer …	Values replaced before excerpts reach the model

The plugin never stores API keys. A dedicated provider/endpoint is configured in DSH; the plugin only selects a registered provider + model route.

Token accounting

There is one model call per confirmed injection:

1. Curator input — system prompt + the project dossier (notes, previous brief, bounded excerpts). Shown as an estimate.
2. Curator output — the brief, capped by curator.maxTokens.
3. Injection — the brief + your notes + the reminder wrapper, added as input tokens to the next normal conversation request.

The confirmation dialog shows all three estimates. They are local heuristics, not a billing guarantee; the panel records the provider-reported usage when available.

Status reads and the transcript

The confirmation layer needs host-side status (sources, curator route, token estimates). It reads that through DSH's local command channel (/memory inject-status --json and /memory status --json). These are local commands, not model calls: they never enter model context and cost no tokens.

DSH logs command executions, so a memory command row can appear in the detailed transcript when you hover, click, or open the panel. The UI no longer queries status on mount, so opening a blank conversation should not create a command row by itself.

Permissions

• Reads DSH session logs for earlier conversations in the same project, plus local memory files under ~/.dsh/workspace-memory/.
• Writes only brief.md, notes.md, and state.json for the current project.
• Calls the selected LLM route exactly once after you confirm Curate and inject; no other network requests.
• Adds no telemetry.

Privacy and security

• Memory state is local: ~/.dsh/workspace-memory/<project-hash>/.
• Stored files are brief.md, notes.md, and state.json. The plugin does not store full transcripts, reasoning, images, or raw tool output.
• Only when you confirm Curate and inject does the project dossier go to the selected model provider. The confirmation says so explicitly.
• The injected block is marked as untrusted historical background. Treat it as stale and verify it against the files.
• The plugin adds no telemetry of its own and makes no network requests except the confirmed curator call through DSH's llm service.
• This is trusted Host code. Review the source before installing, as with any DSH plugin.

What this plugin is not

It is intentionally not a general memory OS. It does not do automatic recall on every turn, background capture, embeddings/vector search, multi-modal memory, memory tools, skill evolution, multi-agent sharing, or cloud sync. If you want those capabilities, use a dedicated memory system — for example the MemOS DeepSeek Harness adapter, which auto-recalls and captures, or another plugin from the Awesome DSH Plugin list.

Do not enable two automatic injectors on the same project/workspace unless you have planned for duplicate context and token cost. This plugin's value is the opposite trade-off: explicit, bounded, auditable, and silent by default.

Compatibility and status

• Tested with DSH 0.2.1-rc.2 on macOS (Desktop Web profile).
• Node.js >=22.19.0.
• No native dependency, no build step, no embedding model download.
• The client bundle requires remote.commands (declared in its inject list).
• The plugin is a DSH bundle: dsh.bundle.patch plus a Web client module.
• This is an early 0.1.x release. If a DSH preview changes a Host API, the plugin may need an update; pin a known-good release if you need stability.

Development

cd dsh-workspace-memory
node --test test/*.test.js
node --check index.js
node --check client.js
for f in lib/*.js; do node --check "$f"; done

The repository has no runtime dependencies and no build step. The tests cover configuration bounds, session digest extraction, compaction-summary reuse, injection budget and escaping, brief validation, project-root containment, Client slot registration, and a Host integration test that proves status is local, one confirmed injection calls the model exactly once, and pre-step inserts the brief after the first user message.

See docs/architecture.md for the module map and data flow.

Contributing

Issues and pull requests are welcome. Please read CONTRIBUTING.md. For security issues, see SECURITY.md.

License

MIT. See LICENSE.