Skip to content
Back to search

dsh-projects

Project board for DeepSeek Harness — one goal, shared memory, parallel worker agents.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 18 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/fatwang2/dsh-projects with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/fatwang2/dsh-projects'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/fatwang2--dsh-projects/badge.svg)](/listings/fatwang2--dsh-projects)

HTML

<a href="/listings/fatwang2--dsh-projects"><img src="/api/listings/fatwang2--dsh-projects/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

The package is a DSH bundle. `package.json` declares `dsh.bundle.patch` (`cordis.patch.yml` inserts the Host plugin row) and `dsh.client` (the Client module is discovered from the same package), so one installation provides both halves. Install it into a profile in one of four ways.

From npm (recommended)

The package is published to npm as `@fatwang2/dsh-projects`. Ask the agent to run `plugin_manager` with `action: "install_bundle"` and `target` set to the package spec:

- `@fatwang2/dsh-projects` — the `latest` dist-tag, so the install takes the newest release. - `@fatwang2/dsh-projects@0.2.0` — an exact version, when you want to lock it.

A registry install is the easiest to upgrade: the Host records the version it installed, and the Plugins page compares it with the registry and offers **Update** when a newer release exists. The profile then lists `@fatwang2/dsh-projects` in `dsh.profile.bundles` and records the exact version in its `dependencies`:

{
  "dsh": { "profile": { "bundles": ["@fatwang2/dsh-projects"] } },
  "dependencies": {
    "@fatwang2/dsh-projects": "0.2.0"
  }
}

From GitHub

Ask the agent to run `plugin_manager` with `action: "install_bundle"` and `target` set to the repository spec:

- `github:fatwang2/dsh-projects` — the default branch's current commit. - `github:fatwang2/dsh-projects#v0.2.0` — a release tag. Pin a tag to lock the version.

There is no clone and no build step: the Host installs the package and selects the bundle. The profile then lists `@fatwang2/dsh-projects` in `dsh.profile.bundles` and records the spec in its `dependencies`:

{
  "dsh": { "profile": { "bundles": ["@fatwang2/dsh-projects"] } },
  "dependencies": {
    "@fatwang2/dsh-projects": "github:fatwang2/dsh-projects#v0.2.0"
  }
}

From a local directory

Clone the repository, then pass the checkout's absolute path as `target` instead of a spec:

git clone https://github.com/fatwang2/dsh-projects.git

A directory install is a `link:` dependency, so `files` does not filter what runs: edit the sources in place and the next reload picks the changes up.

From the Plugins page

Open **Plugins**, choose **Add plugin** → **Install a third-party plugin**, and paste the same spec — `@fatwang2/dsh-projects@0.2.0` (or the bare name for `latest`) or `github:fatwang2/dsh-projects#v0.2.0` — or the absolute path of a local checkout.

A newly installed Client module needs one page refresh before the **Projects** entry appears. Disabling or removing the bundle leaves every project on disk.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 277 lines
  1. # Projects
  2. A project board for DeepSeek Harness. A project holds one goal: standing
  3. instructions, a workspace, a shared memory file, and a board of tasks. One
  4. coordinator session plans and dispatches; every task runs as a worker subagent
  5. with its own context, and its final message lands on the task for review.
  6. ## Install
  7. The package is a DSH bundle. `package.json` declares `dsh.bundle.patch`
  8. (`cordis.patch.yml` inserts the Host plugin row) and `dsh.client` (the Client
  9. module is discovered from the same package), so one installation provides both
  10. halves. Install it into a profile in one of four ways.
  11. ### From npm (recommended)
  12. The package is published to npm as `@fatwang2/dsh-projects`. Ask the agent to
  13. run `plugin_manager` with `action: "install_bundle"` and `target` set to the
  14. package spec:
  15. - `@fatwang2/dsh-projects` — the `latest` dist-tag, so the install takes the
  16. newest release.
  17. - `@fatwang2/dsh-projects@0.2.0` — an exact version, when you want to lock it.
  18. A registry install is the easiest to upgrade: the Host records the version it
  19. installed, and the Plugins page compares it with the registry and offers
  20. **Update** when a newer release exists. The profile then lists
  21. `@fatwang2/dsh-projects` in `dsh.profile.bundles` and records the exact version
  22. in its `dependencies`:
  23. ```json
  24. {
  25. "dsh": { "profile": { "bundles": ["@fatwang2/dsh-projects"] } },
  26. "dependencies": {
  27. "@fatwang2/dsh-projects": "0.2.0"
  28. }
  29. }
  30. ```
  31. ### From GitHub
  32. Ask the agent to run `plugin_manager` with `action: "install_bundle"` and
  33. `target` set to the repository spec:
  34. - `github:fatwang2/dsh-projects` — the default branch's current commit.
  35. - `github:fatwang2/dsh-projects#v0.2.0` — a release tag. Pin a tag to lock the
  36. version.
  37. There is no clone and no build step: the Host installs the package and selects
  38. the bundle. The profile then lists `@fatwang2/dsh-projects` in
  39. `dsh.profile.bundles` and records the spec in its `dependencies`:
  40. ```json
  41. {
  42. "dsh": { "profile": { "bundles": ["@fatwang2/dsh-projects"] } },
  43. "dependencies": {
  44. "@fatwang2/dsh-projects": "github:fatwang2/dsh-projects#v0.2.0"
  45. }
  46. }
  47. ```
  48. ### From a local directory
  49. Clone the repository, then pass the checkout's absolute path as `target`
  50. instead of a spec:
  51. ```sh
  52. git clone https://github.com/fatwang2/dsh-projects.git
  53. ```
  54. A directory install is a `link:` dependency, so `files` does not filter what
  55. runs: edit the sources in place and the next reload picks the changes up.
  56. ### From the Plugins page
  57. Open **Plugins**, choose **Add plugin** → **Install a third-party plugin**, and
  58. paste the same spec — `@fatwang2/dsh-projects@0.2.0` (or the bare name for
  59. `latest`) or `github:fatwang2/dsh-projects#v0.2.0` — or the absolute path of a
  60. local checkout.
  61. A newly installed Client module needs one page refresh before the **Projects**
  62. entry appears. Disabling or removing the bundle leaves every project on disk.
  63. ## Update
  64. A git install is pinned to the ref it was given: `#v0.2.0` stays that release
  65. until you ask for another one, and a spec with no ref follows the default
  66. branch's current commit. An npm install is pinned too:
  67. `@fatwang2/dsh-projects@0.2.0` stays that version, and a bare name installs
  68. whatever `latest` was at install time. To upgrade:
  69. 1. **npm install**: open **Plugins** and the bundle's page. Its **Versions**
  70. section lists the newer releases the registry has, and **Update** replaces
  71. the installed version while keeping the bundle selected — the version
  72. discovery a registry install adds. Without the page, remove the bundle first
  73. — `plugin_manager` → `remove_bundle` with
  74. `target: "@fatwang2/dsh-projects"` — then install the new version:
  75. ```
  76. target: "@fatwang2/dsh-projects@0.2.0"
  77. ```
  78. The removal is not optional: with hot reload, `install_bundle` refuses a
  79. package that is already installed (`already-installed`).
  80. 2. **git install**: install the newer ref — the same `plugin_manager` →
  81. `install_bundle` call with the new tag in place of the old one:
  82. ```
  83. target: "github:fatwang2/dsh-projects#v0.2.0"
  84. ```
  85. `v0.2.0` stands for the release you want; passing `#main` follows the branch
  86. instead of a tag. The Plugins page's **Update** action does the same when it
  87. is offered for a git install. If the profile reports that the bundle is
  88. already installed, remove it first, as in the npm step, then install the new
  89. ref.
  90. `plugin_manager` → `list_plugins` shows what is installed. After an upgrade,
  91. reload the plugin when the Host half changed (the Plugins page asks for a
  92. restart when the profile has no hot reload) and refresh the page when the
  93. Client half changed. Projects, tasks and shared memory are not touched by an
  94. install, an upgrade or a removal: they live in `$DSH_HOME/projects/<projectId>/`.
  95. ## Where it lives
  96. - Left sidebar: a **Projects** entry (a stacked-card glyph drawn on a 24 grid
  97. with `currentColor` strokes) opens the project page. The plugin-market icon
  98. (`icon.svg`) follows the Host's plugin-icon convention instead: a 36 grid,
  99. filled colour, and padded content.
  100. - The page is three columns: **projects** | **main conversation** | **executors**.
  101. - Column 1 lists projects. The `+` glyph in its header opens a create dialog
  102. (name, instructions, optional workspace, autonomy, concurrency); the
  103. panel-left glyph collapses the column to a narrow icon rail, and the two
  104. column edges are draggable (both widths and the collapsed state are
  105. remembered locally).
  106. - Column 2 is the project's coordinator conversation: the real DSH chat with
  107. its composer. **Start coordinator** creates the Session and sends the board
  108. snapshot; the coordinator rules themselves are a **system prompt section**
  109. the Host renders on every step, so a plugin upgrade reaches an existing
  110. Session and the conversation cannot dilute them. The gear glyph in this
  111. column's header opens a
  112. **settings dialog** with a left nav of two groups: **General** (project
  113. name, instructions, workspace, **Threads** — concurrency, model and
  114. reasoning effort — and, as its last section, **archive project**) and
  115. **Shared memory**. Archiving takes two clicks (arm, then confirm; the mask
  116. does not dismiss it while armed).
  117. - Column 3 is the Threads panel: five collapsible groups (running, ready for
  118. review, waiting on you = blocked + failed, idle = queued, resolved — folded
  119. by default). The panel head carries two glyphs: **search** (unfolds a field
  120. that filters on title and summary, and clears when folded again) and
  121. **filter** (show or hide each of the five groups, plus fold-all/expand-all).
  122. There is no refresh control; a 4s poll keeps the cards current. A card is a
  123. status icon, the title (single line, ellipsised), a relative time, a
  124. one-line summary and optional chips (model, task id) — no body text, no
  125. controls. Click a card to open its detail view in the same column: the
  126. executor's own conversation, with a back button. The task brief is not
  127. repeated there — it is already the first message of that conversation, and
  128. the worker's final message is the output. **Resolve** sits at the top right
  129. of the detail view; **delete** lives only in the card's right-click menu
  130. (two-step confirm).
  131. - Each `projects_dispatch` call in the coordinator conversation renders as a
  132. clickable task card: title, read-only status pill, relative time and a
  133. resolved chip. Clicking it opens that task's detail view (switching projects
  134. first when needed). The card is display-only and never writes task state.
  135. - The agent gets eight tools: `projects_list`, `projects_create`,
  136. `projects_update`, `projects_get`, `projects_add_task`,
  137. `projects_update_task`, `projects_memory` and `projects_dispatch`.
  138. `projects_get` returns the tasks plus an **index** of the shared memory
  139. (section titles and sizes), not the memory text; read one section with
  140. `projects_memory`.
  141. ## The loop
  142. 1. Click the `+` glyph in the first column's header (or call
  143. `projects_create`). The dialog takes a name, the instructions, an optional
  144. workspace, autonomy and concurrency. **Choose folder** opens the Host's own
  145. directory chooser (the same dialog the workspace picker uses), and a project
  146. with no folder inherits the coordinator session's directory. Then click
  147. **Start coordinator**: the page creates the project's coordinator Session,
  148. binds it to the project, sends the board snapshot into it, and shows the
  149. conversation beside the board. The rules are not in that message: they are a
  150. system prompt section the Host renders for this Session alone.
  151. 2. The coordinator splits the goal with `projects_add_task` and dispatches with
  152. `projects_dispatch`. Dispatch returns immediately; the coordinator stays
  153. responsive.
  154. 3. Each worker receives the project instructions, an **index** of the shared
  155. memory (section titles and sizes, not the text — it reads the one section it
  156. needs with `projects_memory`) and the task brief, runs in the project
  157. workspace, and appends durable findings to the shared memory through
  158. `projects_memory`.
  159. 4. When a worker settles, its final message becomes the task output and the
  160. task moves to **Ready for review**. The human accepts it by toggling
  161. **Resolve** in the task detail view. `status` is a single enum and `resolved`
  162. is one of its values: Resolve writes `status: "resolved"`, and toggling it
  163. again sends the task back to `review`. There is no separate `resolved`
  164. boolean. To send work back or add a follow-up, say so in the main
  165. conversation and let the coordinator derive a new task. Deleting a task is in
  166. the row's right-click menu (two-step confirm).
  167. ## Autonomy and Threads
  168. - **Manual** (default): a task needs human approval on the page before the
  169. coordinator may dispatch it. This is the approval point.
  170. - **Auto**: the coordinator dispatches without waiting.
  171. - **Concurrency** — the first field of the settings dialog's **Threads**
  172. section — caps how many tasks run at once (1-8). It is deliberately aligned
  173. with the Host's own subagent pool (`maxActiveSubagents`, default 8), so the
  174. plugin never admits a worker the Host would reject: the ninth task is refused
  175. in the plugin with `Concurrency limit reached (8/8 workers running)`.
  176. ## Data and limits
  177. - Data lives on this machine under `$DSH_HOME/projects/<projectId>/`:
  178. - `project.json` — the project and its tasks.
  179. - `memory.md` — the live shared memory. Workers and the page get an index of
  180. it; the text is read one section at a time.
  181. - `memory-archive.md` — sections moved out of `memory.md` by auto-compaction.
  182. Append-only, and never injected into a prompt. Archived sections are still
  183. readable with `projects_memory` (`action: "read"` falls back to the archive,
  184. and `action: "index"` lists the archived titles).
  185. - `memory.bak.md` — a full copy of the memory taken before each compaction.
  186. Never deleted automatically.
  187. Deleting the plugin does not delete any of it.
  188. - **Sessions are archived, never deleted.** DeepSeek Harness has no way to
  189. delete a session — its own UI says sessions can be archived but are never
  190. deleted. Deleting a task can archive its worker session with
  191. `DELETE /projects-api/projects/:id/tasks/:taskId?session=archive`; the route
  192. only ever touches that task's own `childSessionId`, refuses the coordinator
  193. session and a worker that is still running, and
  194. `?session=1|true|delete|remove|yes` is rejected (400) rather than silently
  195. downgraded to an archive. Archiving frees **no disk space**: it hides the
  196. session from the default sidebar and refuses it further model steps, while
  197. `$DSH_HOME/sessions/` keeps every byte. The page's delete menu offers both:
  198. right-click a task row, choose **Delete**, and the second stage offers
  199. **Delete task only** and **Delete and archive session** (the latter only when
  200. the task has an executor session). A successful archive reports "Task
  201. deleted, session archived."; a 409 — the worker is still running — keeps the
  202. task on the board and asks you to wait for it to finish.
  203. - **Auto-compaction**: after an append or a page save, once the memory exceeds
  204. the project's `memoryBudget` (default 64000 characters, clamped to
  205. 4000–200000) and `autoCompact` is not false, the Host moves whole oldest
  206. sections into the archive until it is down to 60% of the budget. Sections are
  207. never split and the newest one always stays. It backs up first, verifies the
  208. write, and rolls back on any mismatch, so nothing is silently dropped. Turn it
  209. off per project with `autoCompact: false` to keep the memory append-only.
  210. - **Per-task git worktree isolation** (opt-in, off by default): the project
  211. setting `worktreeIsolation` — a boolean, settable with `projects_update` —
  212. gives every task its own checkout at `<workspace>/.worktrees/<taskId>` on
  213. branch `task/<taskId>`, and the worker's `cwd` points there, so two workers of
  214. the same project cannot overwrite each other's files. The workspace must be a
  215. git repository that **already ignores `.worktrees/`**: dispatch refuses with an
  216. actionable error instead of leaving an untracked directory in `git status`, and
  217. a start that fails after creation removes the checkout it just made. The
  218. worktree is **kept after the worker settles** — the human reviews it and merges
  219. it, nothing is merged automatically — and is removed together with its branch
  220. when the task is deleted or the project is archived. When the workspace is not
  221. a git repository (or is missing), isolation degrades instead of failing: the
  222. worker runs in the shared workspace and the task records why in
  223. `worktreeDegraded` / `worktreeNote`.
  224. - Workers are in-process subagents: they stop when the plugin is disabled or
  225. the process exits. There is no cloud execution in this version, and three
  226. planned features are still missing: **scheduled or event-triggered runs**, a
  227. **global pause / reporting policy**, and an **output library** (task outputs
  228. and workspace files collected on the page).
  229. - Project instructions are capped at 16000 characters; each task output keeps
  230. the last 4000 characters of the worker's final message.
  231. - The worker route is a project setting (`model`, `reasoningEffort`,
  232. `agentPreset`) with the same fields overridable per task; empty means inherit,
  233. falling back to the Host default.
  234. ## Design
  235. [docs/DESIGN.md](docs/DESIGN.md) is the design note: the capability comparison
  236. against Claude / Cursor Projects, the prototype architecture, the Host and
  237. Client extension points it builds on, the gaps that need infrastructure rather
  238. than a plugin, and the verification status.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.