shengsheng90/DSH-taskboard

Native local Taskboard plugin for DeepSeek Harness. SQLite-backed projects, Agent claim/review, and a native Web UI — no iframe, no second chat runtime.

DSH Taskboard – a native task‑management plugin for DeepSeek Harness

What it is

  • A plugin (@shengsheng/dsh‑taskboard) that adds a full‑featured Taskboard UI and API to the DeepSeek Harness AI‑agent platform.
  • All data lives locally in a SQLite file (taskboard.sqlite) plus an attachment folder – no external services are required.
  • Provides both a sidebar button / overlay page inside the Harness web client and a head‑less JSON‑CLI (dsh‑taskboard).
  • Exposes a set of in‑process tools (taskboard_*) that agents can call during a turn, enabling agents to list, claim, comment on, and submit tasks for review.

Key capabilities

Feature What you get
Project & task hierarchy Projects have short keys (e.g. DSH) that generate readable IDs like DSH‑42. Tasks have statuses (backlog → todo → in_progress → in_review → done) plus blocked and canceled.
Human‑only actions Approve, accept, return, archive, cancel, force‑takeover, permanent delete – only via the UI or CLI, never via an agent tool.
Agent workflow Agents can claim a todo task, work in the associated workspace, then submit a review. The human must later accept the task as done.
Automation Define per‑project automations (interval, model preset, worker count, quota policy). The scheduler will claim eligible todo items and drive an agent session up to in_review.
CLI dsh‑taskboard offers JSON‑output commands for projects, tasks, relations, attachments, workflows, and storage diagnostics. Exit codes differentiate success, usage errors, storage problems, domain errors, and optimistic‑conflict (TASK_STALE_VERSION).
Configuration Adjustable paths, pagination limits, attachment size caps, worker limits, and refresh intervals via cordis.patch.yml, environment variables, or profile overrides.
Security & recovery SQLite integrity checks on open, explicit backup instructions, and a detailed security design doc.

Installation flow (for a Harness operator)

  1. Detect the running Harness – find the web listener port (default 3080) and its working directory.
  2. Build the plugin – clone the repo, run pnpm install && pnpm build && pnpm pack. This produces lib/ files and a tarball shengsheng-dsh-taskboard-<version>.tgz.
  3. Add the plugin to a profile – use the Harness CLI: dsh plugin --profile web add -w /path/to/tgz (the -w flag is mandatory for pnpm workspaces).
  4. Verify composition – dsh --profile web --dump-config should show a # == @shengsheng/dsh-taskboard layer.
  5. Restart Harness – after adding the plugin, restart the Harness process so the UI bundle is loaded.
  6. Confirm activation – a GET to the Harness root must contain @shengsheng/dsh-taskboard and the client bundle must be reachable (200 response). The sidebar now shows a Taskboard button.

Using the UI

  • Click the Taskboard button in the sidebar footer.
  • Create a project (choose a short key) and then create tasks.
  • Human users move tasks from backlog → todo (approval). Agents claim todo items, work, and submit in_review. Humans finally accept the task as done.
  • The UI offers Board, List, Gantt, Workflow, and Dashboard views, all respecting the current Harness locale.

Using the CLI

# list projects
 dsh-taskboard --database .dsh/taskboard.sqlite project list
# create a project
 dsh-taskboard --database .dsh/taskboard.sqlite project create --key DSH --name "My project"
# create a task
 dsh-taskboard --database .dsh/taskboard.sqlite task create \
    --project <project-id> --title "Ship the plugin"
# claim a task (agents use the tool, humans can do it via CLI)
 dsh-taskboard task claim --task <opaque-id> --expected_version 1

All commands emit structured JSON, making them easy to pipe into scripts.

Agent tools (to be called from a running Harness agent)

  • taskboard_list – list tasks for a specific project.
  • taskboard_get – fetch full task details.
  • taskboard_claim – claim a todo task with optimistic version checking.
  • taskboard_comment – add a markdown comment.
  • taskboard_submit_review – move an owned in_progress task to in_review.
  • taskboard_block, taskboard_release_claim, taskboard_relate – additional lifecycle controls.

Why it matters

  • Provides a native, offline‑first task‑tracking system tightly integrated with the Harness agent runtime, avoiding separate project‑management tools.
  • Enforces a clear separation: agents can only work on tasks; humans retain final acceptance authority, which is essential for safe AI‑assisted development.
  • The SQLite‑backed design keeps the system lightweight and portable, suitable for on‑premise or edge deployments of Harness.

License

  • Apache‑2.0 (see LICENSE).

All details above are taken directly from the repository’s README; no additional features have been inferred.

Related

  • Project
    Ammaar-Alam/minebench

    MineBench is a web‑based benchmark that evaluates LLMs on 3‑D spatial reasoning by having them output voxel coordinates for prompts like “a medieval castle”. It visualises the builds, lets humans compare them head‑to‑head, and ranks models with a Bradley‑Terry system. The platform includes an Arena for pairwise voting, a Sandbox for custom builds, a Gallery of community prompts, and export options (GLB, STL, .vox, .schem). It supports major LLM providers and can be run locally with Node.js, pnpm, and Docker.

  • Project
    5uck1ess/tts-bench

    A benchmarking suite for local text-to-speech models that evaluates speed, objective quality scores, and human-preference rankings across various hardware rigs.

  • Project
    OlympiaAI/raix

    Raix is a Ruby library that adds LLM chat, tool (function) dispatch, and prompt‑chain capabilities to any Ruby class. It wraps multiple providers via RubyLLM/OpenRouter, manages a transcript, offers global/class/instance hooks, supports JSON mode, caching, and prompt caching, and provides a DSL for declaring functions and multi‑step prompts.

  • Project
    IBM/LNN

    LNN is a Python library for neuro‑symbolic AI that represents logical formulas as weighted neural networks, enabling interpretable, differentiable reasoning and learning even with inconsistent or incomplete knowledge.