DSH plugin memory data: backup, migrate, erase

Memory feels permanent until a machine change proves otherwise: a DeepSeek Harness plugin can move every file and still answer nothing. The real lifecycle runs write, index, recall, clean and back up, and skipping a stage only moves the failure later. Understanding that order is what separates a backup that restores recall from a folder of Markdown that restores nothing.

Writing memory through a DeepSeek Harness plugin

A write fixes a memory's scope before any backup tool can preserve it, and a scope chosen badly stays invisible until recall fails.

Writing usually happens when a session ends or when the memory tool is called explicitly. The plugin turns the content into a record and files it under session, project, global or habit scope, which are visibility ranges rather than four copies. A session record serves one conversation, a project record follows a directory, a global record crosses projects and a habit record stores confirmed behavior rules. Choosing the wrong scope does not lose the text, but it guarantees that the right context never appears at the right moment.

Locating the files starts with DSH_HOME, which holds memory, configuration and sessions in most installations. The exact subdirectory is decided by the plugin, so another user's path is a hint rather than a template. Checking the plugin version on the DSH Plugin Hub entry before searching the filesystem avoids comparing structures from different releases. Once the root is known, the four scopes should be identifiable on disk before any copy is made.

Concurrency is the quiet failure in the write stage. When two sessions write the same namespace, the later write may replace the earlier one without a conflict message. If a memory disappears, the first question is whether parallel sessions were running at that time, not whether the plugin lost data. A unique marker with a date or random string makes this test decisive, because the marker either appears in the directory or it does not.

Indexing builds a second copy inside the DSH plugin

The index is a separate structure from the source files, and the search box reads the index rather than scanning the directory.

After a write, the plugin splits the text into retrievable fragments and records their positions in an index. Search hits those fragments, so a complete source file with a missing index produces the familiar result of files on disk and nothing in recall. The index has its own timestamp and location, which is why a plugin upgrade or a directory change can leave it pointing at the old path. Many DSH plugins also keep a cache beside the index, and that cache can survive a migration longer than anyone expects.

Comparing the source timestamp with the index timestamp often explains more than an error log. When the index is older than the sources, the index is stale, and when the format changed across versions it may be unreadable rather than merely late. Rebuilding is the usual repair, but it is not lossless, so the whole memory directory should be copied before the rebuild starts. Testing the rebuild means searching for a word that appears only in the source text, because a successful command is not evidence and a hit is.

Index size also matters over time, since indexing every old session dilutes ranking and slows recall. Retention is therefore part of index health rather than a separate chore. A store that keeps everything does not remember more; it just gives the ranker more distractions to sort through.

Recall is where a DeepSeek Harness plugin spends context

Recall ranks candidates and then truncates them to fit a budget, so the right fragment can exist and still never reach the model.

Before an answer, the plugin collects candidates from the index and orders them by similarity, recency and scope. The context budget then cuts the list, and whatever falls below the line is effectively forgotten for that turn. Users experience this as the model failing to remember, even when the memory is present and correctly indexed.

Scope returns at recall time, because a project record tied to another directory may not participate in the search. A migration that changes directory structure can therefore change which memories are eligible, even if every file arrived intact. Phrasing matters too, since literal matching reacts to wording; asking with a unique term from the original text separates an empty index from a ranking miss.

More memory is not automatically better. Irrelevant fragments occupy budget and push useful ones out, which is why lifecycle work includes deciding what should leave the index. That decision belongs to the clean stage, after recall has shown which records actually earn their space.

Cleaning a dsh plugin memory store without residue

Deleting sources alone leaves the index, caches and configuration behind, and old content can keep surfacing after the files are gone.

The first location is the source memory, checked scope by scope so that one project does not stand in for the whole store. The second is the index, which keeps returning fragments of deleted text until it is removed or rebuilt. The third is the plugin cache and temporary files, which may hold summaries or intermediate results that never looked like memory.

The fourth is configuration and profile references. A settings entry that names a storage root or namespace can recreate an empty directory on the next start, which looks like data returning by itself. Before deleting anything, other profiles should be checked for references to the same location, because one active profile can undo the cleanup. A snapshot should exist before the deletion even when the data is meant to disappear, since reconstructing memory from session history is incomplete at best.

After cleanup, search an old keyword and read the plugin startup log for automatic index rebuilding. An empty search plus a quiet log is the only combination that counts as finished. If either one still shows activity, the cleanup is incomplete and the next start will expose it.

Backing up a dsh plugin memory store for migration

A backup is the whole chain, not one directory, and source files without the index and configuration restore as unsearchable text.

The safest snapshot stops writes, copies the entire memory directory and preserves its hierarchy, because the hierarchy encodes scope. File counts and sizes should be compared after the copy, and the plugin version, core version and real DSH_HOME path should be recorded alongside the data. Flattening the tree saves space and destroys meaning, which makes it a false economy.

1. Stop session writes on the old machine and confirm that no running task can still modify the memory directory.
2. Copy the entire memory directory, including sources, index, cache and plugin configuration, without flattening the tree.
3. Record the plugin version, core version and actual DSH_HOME path with the backup.
4. Restore the directory on the new machine and point DSH_HOME and the plugin configuration at the new path.
5. Rebuild the index once after startup, then test recall with a question from the old environment.
6. Compare the old and new answers, confirm memory is readable, searchable and recallable, then remove temporary copies.

Partial migrations can export selected scopes, but the matching configuration must travel with them. A source-only migration usually presents as a complete set of files and a model that cannot answer questions from them. Full backups are not necessary every day, but the one before an upgrade or a machine move should be full, and the copies should live outside the memory directory. The order write, index, recall, clean and back up is a loop rather than a checklist, and every stage depends on the one before it.

Sources: dsh-memory-plugin plugin entry, plugins and lifecycle, DeepSeek Harness quickstart.