Preface¶

When working on long tasks in DSH, two types of recording needs are often encountered: one is temporary reminders given to the agent, such as “submit the weekly report at 10 AM tomorrow”; the other is status notes, to-do items, and color conventions taken down during development. If these contents are scattered in the conversation, they are lost as the session scrolls; if you return to an external note-taking tool, they are disconnected from the context of the plugin currently being modified. The way dsh-sticky-notes solves this problem is: it inserts a sticky note board into the left sidebar of Harness, while simultaneously exposing four tools (note_create, note_list, note_update, note_delete) to the agent, so that the interface and the tools write to the same storage.

Below is an introduction to this plugin.

What is this¶

dsh-sticky-notes is a DSH plugin maintained by community developer 439436269-ctrl, categorized as “Memory”. It adds a sticky note entry to the sidebar of DeepSeek Harness; clicking it opens a tiled sticky note board. At the same time, it allows the agent to read the same set of notes through four note_* tools.

Its characteristic is that storage falls under the plugin’s sticky_notes storage domain ($DSH_HOME/storages), rather than localStorage. In other words, changing ports, browsers, or restarting the desktop application, the notes remain.

Core Features¶

After checking the official README, the actual capabilities provided include:

• Sidebar Entry and Tiled Board: The sidebar displays a note icon; clicking it opens the board in the main column. Row density can be selected as 2 / 3 / 4 / 5, or auto-fill width, and the selection is remembered.
• Seven Colors: plain, amber, rose, mint, sky, violet, slate. The card body, border, and dot share an accent color, and the toolbar can filter by color.
• Pinning and Trash: Pinned cards are pinned to the top with a pin marker; deleted cards go to the Trash tab, where they can be recovered, permanently deleted, or cleared. A toast is provided to undo deletion.
• Edit Dialog: Clicking a card opens a floating layer containing title, body, color, pin toggle, word count, copy, copy duplicate, archive/restore, and permanent delete. Auto-save occurs approximately 0.55 seconds after typing stops.
• Search, Sort, Export: Text search on title and body; sort by last updated, created time, or title; one-click export of the entire board as Markdown.
• Shortcuts: Ctrl/Cmd+N to create, Ctrl/Cmd+F to focus search, Escape to close.
• Persistent Storage: See above, falling under sticky_notes domain under $DSH_HOME/storages.
• Agent Tools: note_create, note_list, note_update, note_delete.

The board and tools operate on the same data: telling the agent “remember one: submit weekly report at 10 tomorrow, put it in amber”, and a card will appear on the board.

Parameters of the Four Tools¶

These four tools return results as single text blocks, with note IDs in the format note-<base36 time>-<random>.

Installation and Enablement¶

Installation commands come from the original README, supporting both npm and local directory sources:

dsh plugin add @vfvrpq/dsh-sticky-notes      # from npm
dsh plugin add /path/to/dsh-sticky-notes     # from a checkout, while developing

After installation, the bundle patch will insert a line sticky-notes into the dsh.client block to let the web side load lib/client.js. After installing via directory, the application does not need to restart; the host will reload this line. However, already opened tabs will only receive the new bundle on the next load. You can confirm if the line is mounted using the following command:

dsh --profile <name> --dump-config | grep sticky-notes

Runtime environment requires Node >= 22, dependencies @deepseek-ai/cordis ^4.0.1, @deepseek-ai/dsh-storage-domain ^0.2.0-rc.2, @deepseek-ai/dsh-tools ^0.2.0-rc.2. License is MIT, package version 0.2.0.

HTTP Interface¶

The browser side and backend of the board only use one route requiring authentication, mounted under /api, so it first passes the Host/Origin check of the connection service and browser session check:

GET  /api/dsh-notes                 -> { ok, notes: [...] }            (including trash)
POST /api/dsh-notes { action: ... } -> { ok, note?, notes: [...] }
       create      { title?, body, color?, pinned? }
       update      { id, title?, body?, color?, pinned?, archivedAt? }
       archive     { id }        (alias: delete)
       restore     { id }
       purge       { id }
       duplicate   { id }
       clear-trash { }

The route path is injected into the page via globalThis.__DSH_STICKY_NOTES_CONFIG__ = { routePath }, and the browser side does not hard-code the path.

Code Structure¶

If you want to modify this plugin, the directory breakdown given in the official README is:

lib/index.js    wiring: domain, route, tools, page injection
lib/config.js   route path, domain name, limits
lib/palette.js  colour ids shared with the board
lib/notes.js    pure shaping/patching/filtering/ordering (no runtime import)
lib/domain.js   storage domain + repository (archive, restore, purge, duplicate)
lib/route.js    /api/dsh-notes handling
lib/tools.js    specs for the four tools
lib/client.js   browser side: sidebar entry, board, edit box, dictionary, styles
locale/*.json   meta.title / meta.description

lib/notes.js is explicitly labeled as pure functions without runtime dependencies, making it easy to unit test; adapter.test.js mounts the real lib/ using a stubbed Harness package to verify that apply() can wire together the domain, route, tools, and destroy hooks.

Testing¶

Run unit tests directly:

node --test test/*.test.js

Coverage: notes.test.js tests pure shaping, colors, pinning, trash, and sorting; route.test.js tests each HTTP branch; client.test.js tests bundle registration and filtering/sorting text; adapter.test.js tests apply() assembly.

Browser side e2e requires a web host, start with an isolated profile and then drive:

dsh --profile <name> --no-open --port 0      # outputs http://127.0.0.1:<port>/?token=…
node scripts/e2e-notes.mjs --base http://127.0.0.1:<port> --token <token>

The script will create a colored pinned card in the UI, switch the grid to 3 columns per row, search, archive, then restore from Trash, and determine success only if the color, pinning, and content survive across reloads. Evidence of running is in VERIFY.md in the repository.

Use Cases¶

Suitable for the following types of users:

• People who need to leave reminders, status, and color conventions for agents while working on long tasks and want the action to take effect on the board with a single sentence in the conversation.
• People who want to use a programmatic way (API or tool calls) to read/write the same notes, rather than clicking the UI manually.
• People who need to batch create/list/update/delete notes in an automation workflow, treating notes as lightweight structured storage.

Not suitable for the following needs: The official README clearly states there are no folders, tags, or cross-device sync—sync scope is limited to the Host holding that storage domain. Card order is generated by pinning plus sort keys, and drag-and-drop reordering is not supported. The body character limit is 20,000, title limit is 200; extremely long content will be truncated rather than rejected.

Notes¶

• The plugin runs with the permissions of the current dsh process, able to access the domain and tool layer under $DSH_HOME/storages. It is recommended to read the source code and license (MIT) before installation to confirm you accept these capability boundaries.
• The package name on npm is @vfvrpq/dsh-sticky-notes, the GitHub repository is 439436269-ctrl/dsh-sticky-notes, both maintained by the same author. The author’s labeled repository, homepage, and issue entry all point to GitHub.
• This plugin belongs to an entry in the community directory. The community directory is an independent site with no official affiliation with DeepSeek / Huanfang, so do not treat it as an endorsement from an official app store.

Conclusion¶

The value of dsh-sticky-notes lies in combining “on-the-fly notes” and “reminders given to agents” into the same board and storage, saving the step of moving back and forth between the conversation and external notes. The features are restrained and boundaries are clear: no folders, no cross-host sync, no drag-and-drop sorting.

Directory Page: https://www.skillhub.cn/plugins/439436269-ctrl/dsh-sticky-notes
GitHub: https://github.com/439436269-ctrl/dsh-sticky-notes