DSH plugin memory misses: write, index and recall

A DeepSeek Harness dsh memory plugin that forgets is usually not losing data; it is failing to move that data from storage into the model's context. The file exists, the search returns nothing, and the model answers as if the earlier session never happened.

The DSH plugin symptom: memory exists, recall does not

The first useful distinction is between memory that was never written and memory that exists but cannot be retrieved.

A memory plugin has three stages, and they fail differently. The write path decides whether a fact lands on disk, the index decides whether that fact can be found, and recall decides whether the found fragment is injected into the current request. A failure at any stage looks like forgetting from the user's side.

Checking the file first is not a formality; it anchors every later step. If the memory directory has no new record for the session, the index and recall are irrelevant. If the record is there, the investigation moves forward with a known starting point.

The temptation to reinstall appears early because it feels decisive. Reinstalling destroys the state that would have explained the failure and often leaves the index untouched. A few minutes of tracing usually costs less than rebuilding the environment and losing the evidence.

The order is not arbitrary. Starting at recall means guessing at thresholds while an empty file sits unnoticed, and starting at the index means rebuilding something that has nothing to index. Storage first keeps the investigation honest.

Tracing the write path of a DeepSeek Harness plugin

Write failures cluster around permissions, namespaces and concurrency, and each leaves a different footprint.

Directory permissions decide whether the plugin can create or update a memory file at all. A CI user or a sandboxed profile may be able to read the directory but not write to it, which produces a failure that looks like the plugin ignoring the conversation. The write log or a filesystem timestamp is the evidence to check.

Namespaces decide where the write lands, and a correct write to the wrong namespace is indistinguishable from no write. A session opened in a different project or profile may be reading a different memory scope entirely. Comparing the namespace recorded in the session with the directory that received the file resolves this quickly.

Concurrency is the quiet one. Two sessions writing to the same file can overwrite each other, and the surviving record may be the older one. Serializing writes or giving each session its own namespace prevents a class of loss that otherwise looks random.

A marker test is the fastest way to close the write question. Write a distinctive value from a clean session, then look for it in the expected directory before asking the model anything. If the marker is absent, no amount of recall tuning will help.

When the index falls behind a DSH plugin write

When the file exists but search cannot find it, the index is the first suspect and the easiest one to inspect.

An index can lag behind the source files after a migration, an upgrade or an interrupted rebuild. The memory is present on disk, but the retrieval layer is still answering from an older snapshot. Checking the index timestamp against the file timestamp is enough to confirm the gap.

Index scope matters as much as freshness. A rebuild may cover only one namespace or one project, leaving content from another scope invisible. If the index format changed in an upgrade, an old index can exist without being usable by the new code. The symptom in both cases is the same: the file is there and search still misses it.

Rebuilding is usually safe for the source files but not always for the index, so back up the memory directory first. Then rebuild and search for a unique marker that was written before the failure. A successful marker search proves the index is covering the right content, which narrows the remaining problem to recall.

A rebuild is a repair, not a diagnosis. Running it before capturing the old index timestamp destroys the comparison that would show whether lag was the cause. Record the state first, then rebuild.

Recall order in a DSH plugin and why the model never sees the fragment

Recall can fail after a correct write and a fresh index, because retrieval depends on wording, similarity and injection position.

The same fact can be found or missed depending on how the current question is phrased. A high similarity threshold filters out fragments that a human would consider relevant, and a question that shares no vocabulary with the stored note is easy to miss. Rephrasing with a distinctive word from the source is a cheap test.

Injection position matters when the context window is crowded. A memory fragment appended late may be truncated or ignored by the model, even though the recall log shows it was retrieved. Checking the assembled prompt confirms whether the fragment actually reached the model. That check separates a retrieval failure from an injection failure.

Two DSH plugins that both retrieve memory create the strangest symptoms, because two retrieval paths can inject contradictory fragments. Running with only one memory plugin active turns a confusing answer into a countable result. If the behavior becomes stable, the interaction was the problem rather than the stored data.

The recall log is only half the evidence. It shows what the retrieval layer selected, while the assembled prompt shows what the model actually received. Comparing the two prevents a correct retrieval from being blamed for a later truncation.

A DSH plugin verification sequence for memory

A short, repeatable sequence beats a long diagnostic session, because it produces the same evidence every time.

Write a unique marker in a clean session, then search for it before asking the model anything. This separates storage from retrieval without relying on the model's answer. Each later step adds one layer of evidence rather than replacing the previous one.

Keep the sessions small enough that a failure has one plausible cause. A long conversation with several plugins and a full context window produces too many interacting variables to interpret. The sequence is meant to be boring, because boring evidence is what makes a diagnosis repeatable.

A written sequence also makes handoffs cheaper. A colleague who can read six concrete steps will reproduce the result faster than one who inherits a paragraph of conclusions. The steps should name the artifact to inspect, because "check recall" is not an instruction.

1. Confirm the plugin is active and its tools are available in the current profile.
2. Write a unique marker and verify the file exists in the expected namespace.
3. Check the index timestamp and rebuild it if it predates the marker.
4. Search for the marker with a query that shares its distinctive word.
5. Ask the model a question that can only be answered from the marker.
6. Inspect the assembled prompt to confirm the fragment was injected.

If the marker survives every step, the original failure was probably a wording or scope issue rather than data loss. If it disappears at a specific step, that step is the one to fix and to document. Rerunning the same sequence after a change is what turns a fix into a verified result. Check the plugin entry in DSH Plugin Hub before assuming the installed version matches the one you are reading about.

What a resolved DSH plugin memory case looks like

A resolved case has a named stage, a reproducible marker and a rerun that behaves differently.

The record should say whether the failure was write, index or recall, and point to the one observation that decided it. A file timestamp, an index rebuild log or an injected fragment is enough; a long narrative of everything tried is not. The next person should be able to repeat the marker test without reading the whole thread.

The same record should note the plugin version and the namespace, because both can change the outcome. A fix that works in one profile may fail in another, and the note prevents a false generalization. When the case is closed, rerun the minimal sequence once to confirm the behavior actually changed.

A short note is also easier to trust than a polished postmortem written days later. Timestamps, paths and the marker value are the facts that matter, and they are cheapest to capture while the session is still open. Collect them as you go rather than reconstructing them from memory.

Keep the note next to the version pin rather than in a chat thread. The next upgrade is exactly when someone will ask whether the same symptom has appeared before. A dated note with one evidence link answers that question in seconds.

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