Introduction¶

Users running tasks with DSH often encounter replies like this: conclusions buried after the first paragraph, requiring scrolling through several screens for details; citations only provide a path or line number, without the original text; codes like EXP-7 and DEV-1K appear out of nowhere, only understood at the end; further scrolling reveals phrases like “above” or “mentioned earlier,” but the context breaks if you leave the current session.

These are not issues with the model’s capabilities, but rather a lack of constrained reply styles. dsh-plain-talk is the plugin that solves this problem: it adds a switch to the input box. When enabled, the model organizes replies according to fixed rules—conclusion first, control length, self-contained, quote the original text, and explain codes upon first appearance. Below is an introduction to its origin, installation, and usage.

What is this¶

dsh-plain-talk (Chinese name “Say Human Language”) is a reply optimization plugin for DSH, maintained by lizilong1993. It belongs to the model inference category and is marked as 1 star in the community directory. It does not modify the model itself; it only rewrites host-side injected system prompt rules and redoes the input box controls in the browser. It is a pure local prompt constraint scheme. The license is MIT, and the npm version is 0.1.10.

Core Features¶

When the plugin is enabled, it imposes the following hard rules on replies, all written in the system prompt:

1. Conclusion First: The first line directly gives the answer or judgment, without restating the question or writing “Let me take a look.”
2. Default Short: Replies do not exceed 12 lines / 300 words, only expanding in depth when the user explicitly requests it.
3. Self-Contained: It does not use referring words like “above / previous / last round”; internal codes (e.g., EXP-7, DEV-1K, run-3) are written in the form Code (one sentence explanation) upon their first appearance.
4. Readable Citations: When providing file:line, it also pastes the corresponding few lines of the original text.
5. Vocabulary List: Words used by the user, project names, and common terms are presumed to be known; the first round of “research X” still explains X, and it is added to the list only after the reply is delivered. Internal codes are not added to the list and are treated as unknown every time.

In addition, the plugin includes a built-in self-check tool plain_talk_check, which receives a draft and returns a list of issues. The rules section requires the model to call it before sending replies of a completion type or over 12 lines. It is important to note that this is a prompt constraint; plain_talk_check only reminds and does not block sending.

Installation and Usage¶

Installation commands come from the plugin’s original README; choose any of the three sources:

# npm
dsh plugin --profile desktop add dsh-plain-talk

# GitHub
dsh plugin --profile desktop add github:lizilong1993/dsh-plain-talk

# Local directory
dsh plugin --profile desktop add ./dsh-plain-talk

After installation, DSH needs to be restarted. Enabling it works as follows:

1. Open any session, and a smiley bubble icon will appear to the right of the input box permission selector.
2. It is off by default (smiling face); clicking it turns it into a grinning face with three sound waves, indicating the current session is enabled, and it only affects the current session.
3. The switch state is written to $DSH_HOME/plain-talk.json and is preserved after a restart.
4. To enable new sessions by default, set PLAIN_TALK_DEFAULT=on in the startup environment.

The plugin has only one configuration item: the environment variable PLAIN_TALK_DEFAULT (on / off, default off).

Vocabulary List¶

The vocabulary list is a JSON sidecar, located at $DSH_HOME/plain-talk-vocab.json, shared across sessions and isolated by user rather than by project.

Internal codes do not enter the vocabulary list. “Research X” happens in two steps: the first round explains as usual, and it is written into the list only after the reply is delivered; common knowledge words and internal codes are unaffected. You can use the plain_talk_vocab tool in a maintenance session, supporting list / add / remove / classify, or edit the JSON directly.

How it Works¶

The plugin is divided into a host-side and a browser-side component:

• Host-side dsh/index.js registers a system prompt section (identifier plain-talk, order 55), which only returns the rule body when the current session switch is on.
• Browser-side lib/client.js registers into conversation.input.left, rendering an 18×18 smiley button.
• The switch state is read and written via the loopback route /plain-talk/state, listening only on 127.0.0.1 / ::1, with a body not exceeding 8 KB.
• Both the state and the vocabulary list are JSON sidecars, written atomically, with no session events written.

Data and Permissions¶

The plugin only writes $DSH_HOME/plain-talk.json and $DSH_HOME/plain-talk-vocab.json, without internet access, uploading, or reading credentials; if the state file is corrupted, it is treated as “no record.” Note that the plugin runs with the permissions of the current DSH process, so you should check the source code and license before installing.

Applicable Scenarios and Notes¶

It is suitable for scenarios requiring readable, independently forwardable, and verifiable replies, especially tasks involving experimental conclusions, deployment checks, and code change explanations that need to be shown to relevant parties. It is not suitable for scenarios that pursue maximum information density or want the model to freely organize long text, as the rules will compress the length.

The test environment given in the README is: DSH desktop profile, headless run, model command code/deepseek-v4.1-flash（high）, date 2026-11-04, same prompt, same workspace, only toggling the switch. The output comparison in the README shows that after enabling, conclusions are more front-loaded, citations include the original text, and codes are explained, but the length and tokens are not unidirectional downward: for example, B1 “Why do models forget things” saw both word count and tokens drop, while B2 “merge with rebase” saw a word count increase of about 5.4% and a token increase of about 144%. The README also notes that token statistics cover all model steps in the entire round (including thinking and tool calls), so they do not necessarily align with the final reply word count; enabling it adds about 590 input tokens per request.

There are three points to note regarding usage:

• The button position depends on conversation.input.left. After the host is updated, it may move next to other left-side controls, and the button might disappear.
• The vocabulary list is shared by user, not isolated by project, so cross-project vocabulary will mix together.
• The rules are prompt constraints; there is no forced interception if the model does not comply.

Summary¶

dsh-plain-talk does not perform complex proxy orchestration; it simply solidifies rules like “conclusion first, default short, self-contained, quote original text, explain codes on first appearance” into a system prompt, plus a session-level switch and a local vocabulary list. Its value lies in making readability the default behavior without sacrificing the user’s ability to expand on demand. Plugin source code and installation instructions can be found at the GitHub repo lizilong1993/dsh-plain-talk, and the directory page is at https://www.skillhub.cn/plugins/lizilong1993/dsh-plain-talk.

It should be noted that the community directory is an independent site with no official affiliation to DeepSeek / Huafang. The above information is based on the plugin README and the directory page.