What Is dsh-taskboard? A Native SQLite Task Board for DSH

dsh-taskboard is a native local taskboard plugin that lives in the DeepSeek Harness (DSH) sidebar: it treats SQLite as the sole task authority for projects, tasks, comments, attachments, workflows, and automation, letting humans and agents create cards, execute, and review on the same board while keeping responsibilities clear — agents submit work for review and only a human can mark a task done. This article covers what dsh-taskboard is, its core features, complete install/update/uninstall commands, and typical usage.

What Is dsh-taskboard?

dsh-taskboard solves the problem that Harness has no native task board: no iframe, no second chat runtime — a click in the DSH sidebar opens the board, all data lives in a local SQLite file, and humans and agents work on the same surface with separate responsibilities. The following positioning and facts come from the official README (source):

dsh-taskboard (GitHub repository shengsheng90/DSH-taskboard) is maintained by shengsheng90 and open-sourced under the Apache-2.0 license; the npm package is @shengsheng/dsh-taskboard, and it is a workflow UI plugin in the DSH Plugin ecosystem, aimed at the web profile of DeepSeek Harness. It adds a Taskboard button to the Harness sidebar footer that opens a native overlay page, with Board, List, Gantt, Workflows, and Dashboard views. It does not take over sessions or execution: Agent Sessions, Goals, Workspaces, tools, permissions, and the Web Client stay with the harness, and the board only owns the task layer. Tasks carry a stable readable key (for example DSH-42), an opaque id, and an optimistic version; agents claim and process tasks through in-process taskboard_* tools and submit verified work to in_review, while only an authenticated human via the UI or CLI can accept a task as done.

What Are the Core Features of dsh-taskboard?

Its core capabilities revolve around a native task board, SQLite local storage, seven task statuses, a split of acceptance authority, a headless JSON CLI, and a packaged skill: full task management inside Harness, with the power to accept kept firmly in human hands. These features come from the official README (source):

• Native task board: a Harness sidebar button plus a native overlay page, not an iframe and not a second chat runtime.
• SQLite local storage: projects, tasks, comments, relations, attachments, workflows, and automation all live in local SQLite, the sole task authority.
• Seven task statuses: backlog → todo → in_progress → in_review → done, plus blocked and canceled.
• Agent tools split from acceptance: the in-process taskboard_* tools have no accept and no generic status mutation; agents can only submit to in_review.
• Headless JSON CLI: the dsh-taskboard command emits schema-versioned JSON for scripting and interoperability.
• Packaged skill: ships manage-taskboard so agents can operate the board by following a built-in procedure.

How to Install and Enable dsh-taskboard?

Installing dsh-taskboard from the npm package is recommended; if you need the source, build a tarball following the official steps first — never install the raw git source, because the lib directory is not in git and a git install would miss the compiled output. After the install, restart the Harness and the Taskboard button appears in the sidebar footer. Commands and requirements come from the official README (source):

1. Check the toolchain (suggested) — dsh-taskboard needs a recent Node and pnpm 11; confirm your versions first so the build or run does not fail.

2. Install from npm (recommended) — run this in your DeepSeek Harness project root to add it to the web profile:

dsh plugin --profile web add @shengsheng/dsh-taskboard

3. Build a tarball from source (optional) — to audit or modify the code, build and pack first, then install the tarball:

git clone https://github.com/shengsheng90/DSH-taskboard.git
cd DSH-taskboard
pnpm install
pnpm build
pnpm pack

After packing, add the generated tarball to the profile with the -w (workspace root) flag:

dsh plugin --profile web add -w /absolute/path/to/shengsheng-dsh-taskboard.tgz

4. Confirm the write and restart — check that the dependency appears in the profile's package.json, then restart the Harness process; you can also inspect the taskboard configuration layer with --dump-config:

dsh --profile web --dump-config

5. Verify it is loaded — refresh the browser after the restart; the Taskboard button in the sidebar footer means success. From the command line, poll the client resource:

curl -s -o /dev/null -w '%{http_code}\n' http://127.0.0.1:3080/plugins/@shengsheng/dsh-taskboard/client.js

6. Update the plugin — re-run the add command so it resolves the newest npm version (or use the host update command):

dsh plugin --profile web update @shengsheng/dsh-taskboard

7. Uninstall the plugin — remove it from host plugin management, or run the remove command and restart:

dsh plugin remove @shengsheng/dsh-taskboard

Typical dsh-taskboard Usage

dsh-taskboard works as a closed loop: humans create projects and tasks and approve work, agents claim and execute and submit for review, humans accept or return; for automation or scripting, use the built-in automation feature or the JSON CLI. The steps come from the official README (source):

1. Create a project — open the Harness web interface, click Taskboard in the sidebar footer, and create a project with a name and a short key (used to generate readable ids such as DSH-1); leave the Workspace blank for a global project.

2. Create a task — create tasks inside the project; new work starts in backlog (or directly as todo). Write the description in Markdown and attach files by pasting, dropping, or using the file picker.

3. Approve for work — approve backlog tasks to move them to todo, since agents and automation may only claim eligible todo items.

4. Agents claim and execute — an agent claims a task with taskboard_claim (carrying the expected version), works in the bound Workspace, branch, or worktree, verifies the result, then calls taskboard_submit_review to move the work to in_review:

human creates backlog -> human approves todo -> agent/automation claims -> agent works and verifies -> submits in_review -> human accepts done or returns for rework

5. Humans review — open the in_review task, read the result comment and the verification evidence, then choose Accept to mark it done or Return for rework; returning releases the claim.

6. Use the views — switch between Board, List, Gantt, Workflows, and Dashboard as needed; the page follows the Harness language (Chinese or English). After mapping a Workspace, use Open in new session to start a native blank session carrying the exact task context.

7. Automate and script — create an automation for a project on the taskboard page (interval, agent preset, model route, worker count, and quota policy); when enabled, the host scheduler claims eligible todo work, drives a root Agent Session and Goal, and stops at in_review. For scripting, use the JSON CLI:

dsh-taskboard --database .dsh/taskboard.sqlite project list
dsh-taskboard --database .dsh/taskboard.sqlite project create --key DSH --name "My project"
dsh-taskboard --database .dsh/taskboard.sqlite task get --task DSH-1

dsh-taskboard Troubleshooting

The most common dsh-taskboard problems are a missing button, a git-source install without lib, a blank page, and a mismatched toolchain; check the profile, switch to npm or tarball, restart and poll, and align the Node and pnpm versions respectively. Guidance comes from the official README (source):

1. No Taskboard button after install — symptom: the install succeeds but no entry appears in the interface. Cause: the plugin was not added to the web profile, or the Harness was not restarted (plugins load only at boot). Fix: confirm the install used --profile web, restart the Harness, and refresh the browser to check the sidebar footer.

2. Git-source or directory install reports missing lib — symptom: the host logs an import/apply error or warns that the package declares no bundle entry. Cause: the lib directory is gitignored, so a git install gets no compiled output. Fix: do not install the raw git source; use the npm package or follow the official pnpm build && pnpm pack flow and install the tarball.

3. Blank page or client.js 404 — symptom: the board opens empty and a command-line request for the resource returns 404. Cause: no restart after install, or the check ran too early. Fix: restart the Harness, wait for boot to finish, then poll the resource URL and the page manifest until the package name appears.

4. Toolchain version error while building — symptom: pnpm install or pnpm build fails outright. Cause: the Node or pnpm version does not meet the requirement. Fix: upgrade Node to 22 or newer (the 24 line is recommended) and install pnpm 11, then retry the build-and-pack flow.

Use Cases and Notes

dsh-taskboard suits users who want task management as a first-class citizen inside the DSH workflow: multi-task and multi-agent collaboration needs tracking and acceptance, with data kept local and auditable. Use cases and limits come from the official README (source):

Typical scenarios include: human-agent development — a closed loop where humans create cards, agents claim and execute, and humans review; parallel multi-agent work — project worker limits cap concurrent claims and execution; automation pipelines — configure project automations so the scheduler claims work and drives Goals on an interval; and local-first collaboration — data stays in a local SQLite file with no cloud dependency. Limits worth noting: it needs a recent Node (the 24 line with built-in node:sqlite is smoothest) and pnpm 11; the plugin targets the web profile of DeepSeek Harness, and both install and update require restarting the host; the database and attachments land under DSH's local data directory, so for a consistent backup stop the Harness first and copy both the SQLite file (including WAL) and the attachment folder; agents can never self-accept, which is an intentional security design rather than a missing feature; and because the host exposes no proactive quota signal during automation, new rules default to ignore while pause-on-uncertain deliberately halts new claims without cancelling running work.

Project Links

dsh-taskboard is an Apache-2.0 open-source project maintained by shengsheng90, evolving continuously as the native local taskboard for DeepSeek Harness. For the full feature list, screenshots, and plugin details, visit the dsh-taskboard plugin page on this site: dsh-taskboard.

This page is an independent guide rewritten from the plugin's official README — for the authoritative documentation and the latest changes, defer to the source: shengsheng90/DSH-taskboard. A plugin is third-party code that runs on your machine once installed; inclusion is not an endorsement — review the source before installing.