Preface¶

DeepSeek Harness (dsh) is an open-source agent runtime developed by DeepSeek, whose core philosophy is “everything is a plugin”: models, tools, sessions, sandboxes, and interfaces can all be replaced or combined. The official repository is located at deepseek-ai/deepseek-harness. There is also an independent community plugin directory site for discovering and comparing plugins, which has no official affiliation with DeepSeek / Fang Info and should not be treated as an official app store.

A very practical problem arises when using dsh for coding and project modification: when the session is closed, all agreements, lessons learned, and to-do items are scattered. When you reopen the session later, the model will have no knowledge of the architecture you decided on yesterday, your coding preferences, or the deadline you were facing. Some users rely on manually pasting notes, while others have to start over when switching tools. dsh-auto-memory is built to solve this problem: it targets DSH Web, saves memories as local Markdown files, injects them hierarchically, and attempts to automatically consolidate them after each conversation turn.

What is this¶

dsh-auto-memory is a memory plugin maintained by Aik358 for DSH Web GUI. The directory page positions it as: a user-level, project note, and daily log three-layer memory automatic injection and retrieval tool, with a daily reflection panel, visualization dashboard, and settings page, and it can inherit historical memories from other AI tools.

The verified release information is as follows:
- Directory page category: Memory; License: BSD-3-Clause
- GitHub: Aik358/dsh-auto-memory, main language is JavaScript, the repository has 13 stars (the directory page still shows 6, please refer to the GitHub data for accuracy)
- npm package name: @a9i5k4/dsh-auto-memory, the version verified in this article is 0.1.26
- The dsh.client.platform declared in package.json is web, meaning it runs on the web interface, not a headless exclusive package

The problem it aims to solve is straightforward: let the same set of user rules, project conventions, and recent logs be readable by the model in subsequent sessions; avoid having to remember to take notes manually for routine work.

Core Features¶

The repository’s README splits the capabilities into two parts: the memory engine and the interface. Below are only the confirmed features explicitly described in the README and the directory page.

1. Three-layer memory plus one reflection layer

Workspace memories are centrally stored under ~/.dsh/memory/workspaces/, with one subdirectory per workspace. The README notes that files from older versions scattered in each workspace’s .dsh-memory/ directory will be automatically migrated during the first run after upgrade, and the old copies will be retained without deletion. Calendar data is stored in the user-level ~/.dsh/memory/CALENDAR.md, shared across workspaces.

2. Streamlined injection, read details on demand

Each time the system prompt is assembled, the plugin appends a <memory_system> block at the end, which includes user rules, project notes, reflection highlights, the tail of the last 1 day’s logs, external memory paths, incomplete calendar items, and writing rules. The default injection budget is injectBudgetChars: 2400, and only 1 day of recent logs is included. Full files can be retrieved on demand using memory_read / memory_recall, instead of stuffing the entire history into the prompt.

The README also mentions two engineering constraints: static rules should remain byte-stable as much as possible to facilitate DeepSeek’s prefix cache hit; sensitive content such as tokens, keys, and credentials will be filtered out during injection, while the content will still be retained in the file itself.

3. Automatic consolidation after each conversation turn

After each conversation turn, a small sub-agent evaluates the content of that turn, and worthy content will be written to today’s log in the format of - 21:03 [Auto Consolidated] …. Project decisions and architecture key points will be promoted to project notes (with the ## YYYY-MM-DD title), and cross-project rules will be promoted to user-level memory. Casual conversations will be skipped based on a word count threshold, with the default autoConsolidateMinChars set to 240; deduplication is performed by conversation turn; the sub-agent’s own turns will not participate. By default, a maximum of 8 automatic consolidations per day are allowed, with a 30-minute cooldown period, and the cooldown is doubled between 22:00 and 08:00. All these settings can be modified in ~/.dsh/dsh-auto-memory.json or the “Automation” group in the settings page.

When active organization is needed, the model can also call memory_consolidate to extract long-term decisions and preferences from recent logs and write them to MEMORY.md.

4. Dashboard, retrieval, calendar, and cross-tool inheritance

After enabling, a “Memory” entry will appear in the Web sidebar. The floating panel includes overview, logs, notes, reflections, continuation, calendar, and retrieval. The overview page will generate greetings based on morning / forenoon / noon / afternoon / evening, and organize the day’s work into three-level drawers; if you leave for more than 1 hour before reopening, a “Welcome back” prompt will appear along with the tasks completed during your absence. Greetings are cached by time period, and the model will not regenerate them every time the panel is opened.

In addition to keyword search, the retrieval page also has “Smart Retrieval”: expand natural language into 3-6 keywords, scan the three-layer memory and reflections, and then provide answers with sources. The example given in the README is that asking “the pitfalls I encountered when publishing npm last time” will expand to terms like “release / pitfalls / GitHub / npm / push”. The documentation clearly states that no facts not present in the memory will be fabricated.

The calendar is a four-quadrant monthly view, and supports a timeline for the period from 07:00 to 22:00 on the day. When deadlines or appointments are mentioned in the conversation, the model can use calendar_add / calendar_list / calendar_done / calendar_remove to maintain them; incomplete items will be injected into subsequent sessions until marked as done.

The “Continuation” feature is used to discover and import saved memories from other tools. The README specifically cites sources including WorkBuddy, CodeBuddy, Claude Code, Codex, and project convention files. After importing, you can view, access, or remove content by source, and the content will be read on demand instead of being injected as a whole paragraph.

Installation and Activation¶

The installation command given on the directory page is as follows, run it in the DeepSeek Harness terminal:

dsh plugin add github:Aik358/dsh-auto-memory

For reproducible installations, fix the commit hash according to the directory page’s instructions:

dsh plugin add github:Aik358/dsh-auto-memory#commit

Replace commit with the actual commit hash from the repository. The plugin runs with the permissions of the current dsh process, and may execute code during installation. You should review the source repository and license before installing.

The repository README also provides an npm installation path for Web profiles, provided that dsh has been installed and dsh web has been started at least once. Execute in the profile directory:

cd ~/.dsh/profiles/web
pnpm add @a9i5k4/dsh-auto-memory

If you do not have pnpm installed, you can use:

npm install @a9i5k4/dsh-auto-memory

Then edit the package.json in this directory and append to the dsh.profile.bundles array:

"@a9i5k4/dsh-auto-memory"

Save the file and restart dsh web. If the “Memory” entry appears in the sidebar, the plugin has been successfully attached. The README also notes that pnpm v11 does not install packages released less than 1 day ago by default; to use a new version immediately on the same day, you can set minimumReleaseAge: 0 in the directory’s pnpm-workspace.yaml, or specify the version explicitly, for example pnpm add @a9i5k4/dsh-auto-memory@0.1.26.

Updates can be performed by running pnpm up @a9i5k4/dsh-auto-memory in the same directory, or by using “Check for Updates” in Settings → Auto Memory. Restarting dsh is required for all plugin set changes to take effect.

Typical Usage¶

After installation, most daily work does not require memorizing a set of commands first. According to the design of the README, the plugin will attempt to write to today’s log after a normal conversation ends; you can see “N points automatically consolidated today” in the panel. When manual intervention is needed, the model has these tools registered:

memory_log / memory_note / memory_user / memory_recall / memory_external / memory_maintain / memory_status / memory_reflect / memory_consolidate / calendar_add / calendar_list / calendar_done / calendar_remove

A few usage examples consistent with the documentation:
1. Ask the model to search memory in natural language. Click “Smart Retrieval” on the retrieval page, or directly ask “the pitfalls I encountered when publishing npm last time” in the conversation. After hitting a match, you should see the source (a certain day’s log / project notes / user-level memory) instead of an unattributed summary.
2. Let the calendar follow the conversation. When a deadline or meeting is mentioned in the session, the model should call calendar_add and explain in the reply body that it has been written; use calendar_done after completion. Uncompleted items will be included in the next round of system prompts.
3. Import memories from other tools. Open the “Continuation” panel, view, access, or remove content by source. Connected sources will be marked with ✓, and notes and user-level memories can be processed separately.
4. Modify injection and behavior. Settings → Auto Memory allows you to change the storage path, injection budget, reflection style, interface language (Chinese / English) and font size. You can also directly modify ~/.dsh/dsh-auto-memory.json. The default values given in the repository are as follows:

{
  "userMemoryDir": "~/.dsh/memory",
  "projectMemoryDir": ".dsh-memory",
  "injectEnabled": true,
  "injectBudgetChars": 2400,
  "recentDaysInjected": 1,
  "reflectEnabled": true,
  "reflectStyle": "auto",
  "locale": "zh",
  "autoConsolidate": true,
  "autoConsolidateMinChars": 240,
  "autoConsolidateCooldownMinutes": 30,
  "autoConsolidateDailyMax": 8,
  "externalInjectionChars": 1400,
  "memoryRoot": "~/.dsh/memory/workspaces",
  "dayBoundaryMinutes": 450
}

The default dayBoundaryMinutes is 450, which means 7:30 AM is the new day boundary: work completed before the boundary will be recorded in the previous day’s log, and reflections from the previous day will not start until the boundary is passed. The daily write budget for user-level memory is approximately 4000 words, and approximately 3000 words for project notes; when the limit is exceeded, old content from before today will be compressed first before writing, and if compression fails, the content will be archived to archived-user.md / archive/notes-archived.md, and the README clearly states that no information will be lost. Logs older than 30 days can be distilled into project notes using memory_maintain, with the original text archived to archive/.

Applicable Scenarios and Notes¶

This plugin is more suitable for users who are already using dsh web and need to remember project conventions and recent progress across sessions. If you have used Claude Code, Codex, CodeBuddy or WorkBuddy before and want to import the memories accumulated there, the “Continuation” feature of this plugin is designed for this purpose. It is not a knowledge-graph-based memory plugin (similar plugins in the directory include graph-memory, mnemon, etc.), but rather plaintext Markdown plus automatic injection.

There are several boundaries to clarify before use:
- The plugin runs with the permissions of the current dsh process, and may execute code during installation. Check the GitHub repository and the BSD-3-Clause license before installing; fix the commit hash for reproducible deployments.
- It is designed for Web. The package.json declares the platform as web, do not assume it has the same panel and injection behavior in headless workflows.
- Memory files are plaintext Markdown. The README clearly states that unless the user explicitly requests it, keys will not be written to memory; even if they are, credential-type paragraphs will be filtered during injection, but the content will still remain on disk, so pay attention to directory permissions and backup scope.
- The historical session retrieval of memory_recall relies on the deployed session-query index; local retrieval only will be performed if it is not enabled.
- There are limits on the number and cooldown period for automatic consolidation, and casual conversations will be skipped; do not treat it as “every sentence will be saved to the database”.
- Plugin set changes require a restart of dsh. The current version is iterating rapidly (0.1.0 was released on 2026-08-14 on npm, and 0.1.26 was released just a few days later), so check the README’s migration instructions after upgrading.

Summary¶

dsh-auto-memory organizes user rules, project notes, and daily logs into three layers of local memory, uses streamlined injection to control token usage, and reduces the problem of “forgetting to take notes” through automatic consolidation after each conversation turn. The calendar, smart retrieval, and cross-tool inheritance functions are interfaces and tools built on the same set of files, rather than another cloud account system.

Directory page: https://deepseek-harness-plugin.com/zh-CN/plugins/dsh-auto-memory/

GitHub: https://github.com/Aik358/dsh-auto-memory

npm: https://www.npmjs.com/package/@a9i5k4/dsh-auto-memory