dsh/packages/dsh

One-Line Pitch

Adds office collaboration and team management capabilities to DeepSeek Harness: brings projects, tasks, meetings, transcripts, and documents into a shared workspace, enabling DSH Agents to read, edit, and follow up on these works like team members.

Core Capabilities

• Jira-style Project Board: Each project comes with a three-column workflow (To Do / In Progress / Done), supporting drag-and-drop, assignees, priority, progress, and due dates
• Multi-dimensional Task Table: Supports custom fields including text, numbers, dates, single-select, multi-select, and person fields, with in-place editing saved to the project's shared view
• Personal & Team Views: My Tasks, Personal Board, Personal Calendar, and cross-project aggregation all display on the same business data without copying
• In-browser AI Meeting: Browser VAD auto-slices → local Whisper transcription → meeting Supervisor identifies action items, decisions, and risks in real-time
• Traceable Work Relationships: Projects, meetings, tasks, and Markdown documents are interconnected through fields like intent_key and evidenceFromSequence, allowing you to find meetings and documents by following tasks
• Shared Write Channel: Agent tools and browser Remote both go through the same FlowboardService, with writes unified through authorization, validation, idempotency, optimistic locking, transactions, and auditing

Technical Implementation

• Language: TypeScript (ESM), private workspace packages are aggregated into a single plugin tarball at build time
• Key Dependencies: @flowboard/dsh-service (Host-side Cordis service + Agent tool registration), fastify (embedded HTTP API), node:sqlite (persistence), whisper.cpp (linux-x64 native CLI, shipped with the package), antd + @dnd-kit/* (browser UI), @deepseek-ai/dsh-typert-protocol (Host/Client Remote bridge)
• Architecture Pattern: DSH Cordis dual-end plugin. Host side mounts @flowboard/dsh via cordis.patch.yml, constructs FlowboardService (extending TypertRemoteService), and starts embedded Fastify, SQLite, Whisper Worker; Client side packages/dsh-client/src/client/index.ts registers conversation.view (FlowboardView) and conversation.input.dock (FlowboardMeetingDock) two slots via ctx.slots.inject
• Entry Files: packages/dsh/src/index.ts (re-export only), packages/dsh-service/src/index.ts (Host main entry), packages/dsh-client/src/client/index.ts (Browser main entry), packages/server/src/runtime.ts (embedded runtime)

Use Cases

For teams that want their collaborative work to have "structure" without leaving DeepSeek Harness: tasks, decisions, and risks generated verbally in meetings are automatically transcribed and placed on the project board; Agents can directly read and edit these tasks within their own sessions and沉淀 the outputs back into the same task context. Suitable for small to medium-sized teams that need to connect "meeting → task → document", especially those already using DSH Agent for collaboration.

Prerequisites & Compatibility

Installation

dsh plugin --profile web add github:juntaoding/Flowboard#path:packages/dsh

Configuration Options

The plugin has no runtime visual configuration page; you can adjust mount parameters in cordis.patch.yml in the installation directory.

FAQ

Q: Where is data stored? Will it be lost after uninstall?

A: Default writes to $DSH_HOME/flowboard; if DSH_HOME is not set, it's ~/.dsh/flowboard. dsh plugin --profile web remove @flowboard/dsh does not automatically delete this directory; to clean up, first stop DSH, then manually backup and delete.

Q: Where are browser-side meeting recordings uploaded?

A: Browser VAD encodes PCM into WAV slices, pushes to Host's Fastify upload endpoint via DSH Typert Remote through flowboard_upload_audio, lands in temporary files under $DSH_HOME/flowboard/uploads, read and deleted by the same process's Whisper Worker; no third-party services involved.

Q: Will the browser read my LLM API token?

A: No. FlowboardService only reads its own embedded access token (randomly generated by default); the browser only communicates with Host's Typert Remote; upstream model tokens are managed by DSH Host; browser code cannot access them.

Q: Can I use meeting transcription on macOS or Windows?

A: Built-in Whisper CLI only ships Linux x64 version with the package; packages/server/src/whisper-runtime.ts throws "The bundled Flowboard transcriber does not support …" on other platforms. To support other platforms, either add a validated vendor variant, or use FLOWBOARD_TRANSCRIBE_COMMAND / FLOWBOARD_TRANSCRIBE_ARGS to point to locally available ASR commands.

Q: Will Agent calling flowboard_create_task cause errors?

A: Generally not. The tool first finds the current writable project via client.snapshot; missing fields (like title) will create a revisable entity with "Unnamed Task" first, then let subsequent calls modify it; only irreversible operations like missing writable project / writable team, insufficient permissions, or deletion will actively throw errors and wait for user confirmation.

Q: How do I upgrade the plugin?

A: First download the new version's Alpha tarball and SHA256SUMS and verify, then use dsh plugin --profile web add --force ./flowboard-dsh-*.tgz to overwrite install; current Alpha does not provide database migration chain; when schema version changes, manually backup and clear $DSH_HOME/flowboard before starting.

Q: What data exists by default after first startup?

A: First startup automatically seeds a local Owner account (tenant-local), Default Team, Default Project, three-column default workflow (To Do / In Progress / Done), and two default views (project board and task table); you can rename in DSH settings and create real team members.

Q: Is the plugin open source?

A: Yes. Repository uses MIT License; homepage has CONTRIBUTING.md / SECURITY.md / CODE_OF_CONDUCT.md / THIRD_PARTY_NOTICES.md; Alpha stage only accepts v*-alpha.* tags and publishes via GitHub prerelease.

Learning Curve

Intermediate — ordinary users only need to install, let Agent create the first batch of tasks, and hold a meeting in the browser; however, understanding concepts like tasks, intents (intent_key / evidenceFromSequence / delivered vs analyzed water levels) requires familiarization; customizing transcription or deploying distributed versions requires reading design documents under docs/architecture/.

Known Issues & Limitations

• Built-in Whisper CLI only provides Linux x64 vendor; macOS / Windows / Linux arm64 will throw platform unsupported error when starting meetings; need to self-provide ASR and connect via environment variables (packages/server/src/whisper-runtime.ts:36)
• Currently only one local Owner account; no complete registration, invitation, token management UI (README.zh-CN.md:182)
• Persistence only supports SQLite; no PostgreSQL adapter or distributed deployment plan (README.zh-CN.md:183)
• Database schema_migrations currently fixed at version 3; Alpha stage does not provide production migration chain; schema evolution requires manually clearing $DSH_HOME/flowboard before rebuilding (packages/server/src/database.ts:6, README.zh-CN.md:185)
• Default API listens on 127.0.0.1, not directly serving externally; for remote access, need to use reverse proxy or change FLOWBOARD_HOST to 0.0.0.0 and provide valid token (packages/server/src/runtime.ts:29)
• Browser VAD and Whisper transcription are serially processed; default Worker concurrency is 2, max segment 15 seconds; long meetings won't lose words but real-time performance depends on model speed (packages/server/src/worker.ts:54, packages/dsh-client/src/client/use-audio-recorder.ts:13)
• Not every DSH Session is automatically bound to tasks; cross-Session execution tracking is still a product evolution direction (README.zh-CN.md:186)
• Installation package includes complete ggml-small model and Linux shared libraries; Alpha tarball size is ~430 MB, provided via GitHub Release to avoid npm string limit (CHANGELOG.md:11)

English | 简体中文

Let work happen naturally in the Harness while keeping the team aligned without extra management overhead.

Flowboard is an open-source office collaboration and team management plugin for DeepSeek Harness (DSH). It brings goals, meetings, people, agent execution, progress, and documents into one coherent workflow, so work can move continuously from discussion to execution and shared knowledge. Tasks are not the boundary of the product; they are the backbone that supports this way of working.

Alpha: 0.1.2-alpha.5 is still at an early validation stage. APIs, data structures, and installation procedures may change incompatibly. It is intended for local evaluation and small-team trials, not stable production deployments.

Management Without the Busywork

Traditional task management makes employees do the same work twice: first they meet, communicate, and execute, then they open another system to create tasks, assign owners, update progress, and organize documents. The management system records a manually maintained copy of the work rather than the work itself. As soon as people stop updating it, the board becomes inaccurate.

AI-assisted work makes this problem even more visible. People already use agents in the Harness to research, write, analyze, plan, and execute. If those results remain in individual sessions, the team still cannot see who is doing what, how work is progressing, or what has been produced. Someone eventually has to copy the information and report it manually.

Flowboard changes how task information is created:

• When work begins, goals and meeting action items become tasks, owners, and plans.
• While work is in progress, members and agents execute and update progress in the same task context.
• When work is completed, documents, decisions, and supporting material return to the original task and project.
• When the team collaborates, every member and agent reads the same authoritative state and continues from there.

People still complete tasks, but no longer have to manage a separate copy of them. Management happens as the work happens.

One Operating Model Across the Harness

The Harness is where people and agents work. Flowboard provides its collaboration and organizational memory layer. Goals set direction, meetings create alignment, people and agents execute together, progress stays current, and documents preserve the outcome. Tasks connect these stages instead of becoming a form that employees must maintain outside their conversations.

An employee sets a goal / the team holds a meeting
                         ↓
The Harness agent understands intent and existing context
                         ↓
Flowboard creates tasks, ownership, plans, and linked documents
                         ↓
Members and agents continue execution in their own sessions
                         ↓
Progress, issues, documents, and decisions return to one task context
                         ↓
The next member or agent continues from the actual state of the work

DSH remains responsible for sessions, models, agents, and the plugin lifecycle. Flowboard does not create a second agent entry point or make DSH depend on a standalone application. Users install only @flowboard/dsh; the UI and agents then share the same FlowboardService, data, and authorization rules.

How a Complete Workflow Unfolds

Consider a product meeting:

1. Before the meeting: A member asks an agent to read project progress, incomplete tasks, and related documents, then assemble the meeting context.
2. During the meeting: Flowboard segments audio locally in the browser and transcribes it with the bundled Whisper runtime. The meeting Supervisor continuously identifies action items, decisions, risks, and supporting material.
3. Live revisions: “Assign it to Alex,” “No, change that to Sam,” and “Finish it by next Wednesday” are understood as successive revisions to one intent rather than three duplicate tasks.
4. After the meeting: Tasks, owners, due dates, decisions, risks, the meeting summary, and linked documents are already part of the project. No second round of manual data entry is needed.
5. Continued execution: The owner returns to their Harness session and asks an agent to research, write, or execute. Task status and outputs continue to accumulate in the original context.

Managers see state produced by the work itself, not a status report filled in afterward.

What You Get

Quick Start

Requirements

• Linux x64. The bundled native Whisper runtime is currently available only for this platform.
• Node.js 22.19+ or 24+.
• DeepSeek Harness 0.1.0-rc.6, with the dsh command available.
• About 500 MB of free disk space. The plugin includes the complete ggml-small model.

Install From a GitHub Release

Every Alpha tag creates a GitHub prerelease containing the complete plugin tarball and SHA256SUMS. Because the package includes the full Whisper model and is larger than npm clients can publish reliably, Alpha builds are distributed through GitHub Releases:

FLOWBOARD_VERSION=0.1.2-alpha.5
curl -LO "https://github.com/juntaoding/Flowboard/releases/download/v${FLOWBOARD_VERSION}/flowboard-dsh-${FLOWBOARD_VERSION}.tgz"
curl -LO "https://github.com/juntaoding/Flowboard/releases/download/v${FLOWBOARD_VERSION}/SHA256SUMS"
sha256sum -c SHA256SUMS
dsh plugin --profile web add "./flowboard-dsh-${FLOWBOARD_VERSION}.tgz"
dsh web

Open http://127.0.0.1:3080 and select Flowboard in the main DSH session view.

The release asset includes the complete Whisper model and is approximately 430 MB. Install it only after the checksum succeeds.

First Use

On first launch, Flowboard creates a local Owner, a default team, and a default project so you can start immediately. Data is stored in $DSH_HOME/flowboard, or ~/.dsh/flowboard when DSH_HOME is not set.

1. Explore the Workspace

When you open Flowboard, the sidebar provides the complete office navigation:

• Home: Today's tasks, schedule, active projects, and recent AI operations.
• My Tasks / Personal Board / Personal Calendar: Work aggregated across projects for the current person.
• Meetings / Documents: Team meetings and knowledge outputs.
• People / Teams: Organization and permission management.
• Projects: Overview, Jira board, task list, meetings, documents, and members for each project.

A good first step is to rename Default Team and Default Project, then add real members, workflows, and tasks.

2. Ask an Agent to Create the First Tasks

Return to a DSH conversation and describe the work directly instead of filling in a complete form first:

Create a project for the product Alpha launch and break design review,
plugin packaging, installation verification, and release notes into tasks.

Assign plugin installation verification to me, set the priority to high,
and make it due this Friday.

List the tasks assigned to me that do not have a due date yet.

Flowboard's agent tools read the current workspace, choose a writable project, and create or update real tasks within the user's permissions. When non-critical fields are missing, they can first create a provisional entity that remains easy to revise. Deletions and irreversible operations still require confirmation.

3. Start the First AI Meeting

On the Flowboard home page, select Start a meeting → Start now, allow microphone access, and discuss normally. Instant meetings automatically execute validated safe operations by default. When creating a meeting from the meeting list, you can also choose record only, suggest before execution, or automatically execute safe operations.

During the meeting, you can monitor:

• whether live transcription continues to arrive;
• whether the Supervisor is waiting for delivery, analyzing, or caught up;
• whether action items are created, revised, or withdrawn;
• whether AI questions, project documents, and operation records enter the same meeting context.

When you select End meeting, Flowboard drains the final audio segment, waits for transcription and intent processing to converge, generates a summary, and then closes the meeting. Open the project board afterward to review the resulting tasks and documents.

4. Continue in the Harness

Meetings are only one input. You can continue by asking an agent:

Summarize unresolved risks from the last three meetings in the product project.

Turn the technical decisions from this discussion into a project document
and link it to the relevant tasks.

Read the context for FLOW-12, complete the research, then update the task's
progress and conclusions.

This is the core Flowboard workflow: stay in the Harness, avoid maintaining a duplicate task system, and let agents continue from shared work state.

Installation Management

Upgrade to an Alpha build you have already downloaded:

dsh plugin --profile web add --force ./flowboard-dsh-*.tgz

Uninstall the plugin:

dsh plugin --profile web remove @flowboard/dsh

Upgrading or uninstalling does not automatically delete $DSH_HOME/flowboard. To remove data, stop DSH first, back up the directory, and verify the exact path before deleting it.

Data and Security Boundaries

• DSH is the only host and startup entry point. The Flowboard API, SQLite database, and Worker start and stop with the plugin lifecycle.
• The browser calls the Host only through DSH Typert Remote and never reads or stores an upstream API token.
• Embedded mode generates a random 32-byte access token on every startup and uses it only inside the Host.
• The Whisper CLI, shared libraries, and ggml-small model are bundled with the plugin. Default transcription does not depend on a system installation of Whisper or ffmpeg.
• Audio is processed by the local Flowboard runtime. The Worker removes completed or failed temporary segments.
• Every write goes through the same server-side authorization, validation, idempotency, optimistic locking, transaction, and audit pipeline.

For implementation details, see DSH Native Plugin Architecture and Release Specification and System Architecture Overview. These design documents are currently maintained in Chinese.

Alpha Limitations

• The default setup currently uses one local Owner. Full account sign-in, invitations, and token management are not yet integrated.
• Persistence currently uses SQLite. There is no PostgreSQL adapter or distributed deployment option.
• The bundled Whisper runtime supports Linux x64 only. Other platforms require additional validated vendor variants.
• The database schema is evolving rapidly and there is no production migration chain yet.
• Agents can read the workspace, create and update projects, tasks, and documents, and process meeting intents. However, not every DSH session is automatically bound to a task; richer execution tracking across sessions remains a product direction.

Local Development

git lfs install
git lfs pull
corepack enable
pnpm install --frozen-lockfile
pnpm dev

pnpm dev runs the full checks, builds a real npm tarball, installs it into an isolated .dsh-dev profile with dsh plugin --profile web add, and starts dsh web. It does not use workspace symlinks or a temporary --patch, so it exercises the same installation boundary as an end user.

Before releasing:

pnpm run check
pnpm run plugin:pack
pnpm run plugin:package-check
pnpm run plugin:install-check
pnpm run release:check

Only @flowboard/dsh is publicly distributed. Contracts, Server, Host, Client, and the Typert adapter remain private source modules in this repository and are assembled into one plugin package during the build. The Whisper model is stored through Git LFS; source assets, staging directories, and final tarballs are all checked for SHA-256 integrity and executable permissions.

Open Source and Contributing

Flowboard is available under the MIT License. Before opening an issue or pull request, read the Contributing Guide, Security Policy, Code of Conduct, and Third-Party Notices. Version changes are recorded in the Changelog.

Alpha releases accept only v*-alpha.* tags and are published as GitHub prereleases. Release packages must pass a real DSH installation, web startup, API health check, and Whisper asset audit.

Documentation

The following technical documents are currently maintained in Chinese:

• DSH Native Plugin Architecture and Release Specification
• System Architecture Overview
• Workspace and AI Meeting Design
• Meeting Supervisor Design
• Complete Refactoring Notes